Repository: 2gis/mapsapi
Branch: master
Commit: f7ce5f1182c6
Files: 487
Total size: 3.5 MB

Directory structure:
gitextract_whh8pbvz/

├── .csscomb.json
├── .editorconfig
├── .eslintrc
├── .github/
│   └── workflows/
│       └── test.yml
├── .gitignore
├── .npmignore
├── CONTRIBUTING.md
├── LICENSE
├── LICENSE_EN
├── README.md
├── app/
│   ├── config.js
│   ├── index.html
│   ├── index.js
│   └── loader.js
├── assets/
│   ├── cluster_realworld.js
│   └── heat_realworld.js
├── config.main.json
├── functional-tests/
│   ├── .gitignore
│   ├── README.md
│   ├── classes/
│   │   ├── WAPI/
│   │   │   ├── __init__.py
│   │   │   ├── dataWorker.py
│   │   │   └── request.py
│   │   ├── __init__.py
│   │   ├── components/
│   │   │   ├── __init__.py
│   │   │   ├── balloon.py
│   │   │   ├── callout.py
│   │   │   ├── component.py
│   │   │   ├── map.py
│   │   │   ├── mapsapi_sources.py
│   │   │   ├── marker.py
│   │   │   ├── page.py
│   │   │   └── zoom_control.py
│   │   ├── exceptions/
│   │   │   ├── __init__.py
│   │   │   └── exceptions.py
│   │   ├── mapsapi_base_test.py
│   │   └── util/
│   │       ├── __init__.py
│   │       ├── decorators.py
│   │       ├── geo_types_map.py
│   │       ├── link_generator.py
│   │       ├── misc.py
│   │       ├── scripts.py
│   │       ├── transport_types_map.py
│   │       └── unescape.py
│   ├── config/
│   │   ├── __init__.py
│   │   ├── config.ini
│   │   └── config.my.ini
│   ├── pep8
│   ├── pep8-hook.sh
│   ├── prepare.sh
│   ├── run.sh
│   ├── template_render.sh
│   ├── templates/
│   │   ├── __init__.py
│   │   ├── base.html
│   │   └── content.py
│   └── tests/
│       ├── __init__.py
│       ├── balloon_test.py
│       ├── bounds_test.py
│       ├── event_test.py
│       ├── firm_callout_test.py
│       ├── geo_clicker_test.py
│       ├── loader_test.py
│       ├── marker_test.py
│       ├── ruler_test.py
│       └── zoom_test.py
├── gulp/
│   ├── deps/
│   │   ├── build.html
│   │   ├── deps.js
│   │   ├── index.js
│   │   └── packs.js
│   ├── sprite-template.mustache
│   ├── tasks/
│   │   ├── build.js
│   │   ├── buildLeaflet.js
│   │   ├── buildScripts.js
│   │   ├── buildStyles.js
│   │   ├── buildTest.js
│   │   ├── clean.js
│   │   ├── collectImagesStats.js
│   │   ├── collectImagesUsageStats.js
│   │   ├── concatScripts.js
│   │   ├── copyAssets.js
│   │   ├── copyImg.js
│   │   ├── copyIndexPage.js
│   │   ├── dev.js
│   │   ├── doc.js
│   │   ├── generateSprites.js
│   │   ├── imageMinify.js
│   │   ├── lint.js
│   │   ├── lintCSS.js
│   │   ├── lintJS.js
│   │   ├── loadProjectList.js
│   │   ├── loader.js
│   │   ├── rebuildStyles.js
│   │   ├── server.js
│   │   ├── test.js
│   │   └── watch.js
│   └── util/
│       ├── buildCSS.js
│       ├── buildEnd.js
│       ├── csslint/
│       │   ├── gulp-csslint.js
│       │   └── lib/
│       │       ├── csslint.js
│       │       └── parserlib.js
│       ├── destCSS.js
│       ├── error.js
│       ├── gendoc.js
│       ├── projectList.js
│       ├── stat.js
│       └── templateStream.js
├── gulpfile.js
├── package.json
├── src/
│   ├── DGAjax/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── src/
│   │   │   └── DGAjax.js
│   │   └── test/
│   │       └── DGAjaxSpec.js
│   ├── DGAttribution/
│   │   ├── lang/
│   │   │   ├── ar.js
│   │   │   ├── cs.js
│   │   │   ├── en.js
│   │   │   ├── es.js
│   │   │   ├── it.js
│   │   │   └── ru.js
│   │   ├── skin/
│   │   │   └── basic/
│   │   │       └── less/
│   │   │           └── dg-mapcopyright.less
│   │   ├── src/
│   │   │   └── DGAttribution.js
│   │   ├── templates/
│   │   │   └── copyright.dust
│   │   └── test/
│   │       └── DGAttributionSpec.js
│   ├── DGCore/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── skin/
│   │   │   └── basic/
│   │   │       └── less/
│   │   │           └── dg-core.less
│   │   └── src/
│   │       ├── DGCore.js
│   │       ├── DGplugin.js
│   │       └── DGthen.js
│   ├── DGCustomization/
│   │   ├── skin/
│   │   │   └── basic/
│   │   │       ├── less/
│   │   │       │   ├── dg-customization.less
│   │   │       │   ├── leaflet.ie.less
│   │   │       │   └── leaflet.less
│   │   │       └── skin.config.js
│   │   ├── src/
│   │   │   ├── DGCustomization.js
│   │   │   ├── DGMap.ApiKeyValidator.js
│   │   │   ├── DGMap.BaseLayer.js
│   │   │   ├── DGMap.Drag.js
│   │   │   ├── DGMap.TilesCheck.js
│   │   │   ├── DGMap.js
│   │   │   ├── DGMobileImprove.js
│   │   │   └── DGPolyUtil.js
│   │   └── test/
│   │       ├── CanvasSpec.js
│   │       ├── DGCustomizationSpec.js
│   │       ├── DGMap.BaseLayerSpec.js
│   │       ├── DGMapSpec.js
│   │       ├── GridLayerSpec.js
│   │       ├── Map.DragSpec.js
│   │       ├── MapSpec.js
│   │       ├── PathSpec.js
│   │       ├── PopupSpec.js
│   │       ├── UtilSpec.js
│   │       └── ValidatorApiKeySpec.js
│   ├── DGDust/
│   │   ├── doc/
│   │   │   └── DGDust.md
│   │   ├── src/
│   │   │   └── DGDust.js
│   │   └── test/
│   │       └── DGDustSpec.js
│   ├── DGEntrance/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── src/
│   │   │   ├── DGAnimation.js
│   │   │   ├── DGArrowPathTransform.js
│   │   │   ├── DGArrowTipTransform.js
│   │   │   ├── DGBezierCurves.js
│   │   │   ├── DGComplexPath.js
│   │   │   ├── DGEntrance.js
│   │   │   ├── DGEntranceArrow.js
│   │   │   ├── DGEntranceArrowShape.js
│   │   │   ├── DGMetric.js
│   │   │   ├── DGRenderer.js
│   │   │   └── DGVertexTransform.js
│   │   └── test/
│   │       ├── DGArrowShapeSpec.js
│   │       ├── DGBezierSpec.js
│   │       ├── DGMetricSpec.js
│   │       ├── DGTransformSpec.js
│   │       └── EntranceSpec.js
│   ├── DGFullScreen/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── lang/
│   │   │   ├── ar.js
│   │   │   ├── cs.js
│   │   │   ├── en.js
│   │   │   ├── es.js
│   │   │   ├── it.js
│   │   │   └── ru.js
│   │   ├── skin/
│   │   │   ├── basic/
│   │   │   │   └── less/
│   │   │   │       ├── dg-control-round.less
│   │   │   │       └── dg-fullscreen.ie.less
│   │   │   ├── dark/
│   │   │   │   └── less/
│   │   │   │       └── dg-control-round.less
│   │   │   └── light/
│   │   │       └── less/
│   │   │           └── dg-control-round.less
│   │   ├── src/
│   │   │   ├── DGFullScreen.js
│   │   │   ├── DGScreenfull.js
│   │   │   └── LegacyFullScreen.js
│   │   └── test/
│   │       └── DGFullScreenSpec.js
│   ├── DGGeoclicker/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── lang/
│   │   │   ├── cs.js
│   │   │   ├── en.js
│   │   │   ├── es.js
│   │   │   ├── it.js
│   │   │   └── ru.js
│   │   ├── skin/
│   │   │   ├── basic/
│   │   │   │   └── less/
│   │   │   │       ├── dg-building-callout.less
│   │   │   │       ├── dg-firm-card.less
│   │   │   │       ├── dg-link.less
│   │   │   │       ├── dg-map-geoclicker.less
│   │   │   │       ├── dg-popup.ie.less
│   │   │   │       ├── dg-popup.less
│   │   │   │       ├── dg-preloader.less
│   │   │   │       ├── dg-schedule.ie.less
│   │   │   │       └── dg-schedule.less
│   │   │   ├── dark/
│   │   │   │   └── less/
│   │   │   │       ├── dg-building-callout.less
│   │   │   │       ├── dg-firm-card.less
│   │   │   │       ├── dg-map-geoclicker.less
│   │   │   │       ├── dg-popup.ie.less
│   │   │   │       ├── dg-popup.less
│   │   │   │       ├── dg-schedule.ie.less
│   │   │   │       └── dg-schedule.less
│   │   │   └── light/
│   │   │       └── less/
│   │   │           ├── dg-building-callout.less
│   │   │           ├── dg-firm-card.less
│   │   │           ├── dg-map-geoclicker.less
│   │   │           ├── dg-popup.less
│   │   │           ├── dg-schedule.ie.less
│   │   │           └── dg-schedule.less
│   │   ├── src/
│   │   │   ├── ClampHelper.js
│   │   │   ├── Controller.js
│   │   │   ├── DGGeoclicker.js
│   │   │   ├── View.js
│   │   │   ├── handler/
│   │   │   │   ├── ApiError.js
│   │   │   │   ├── CityArea.js
│   │   │   │   ├── Default.js
│   │   │   │   ├── Handler.js
│   │   │   │   ├── House.View.js
│   │   │   │   ├── House.js
│   │   │   │   ├── POI.js
│   │   │   │   └── Sight.js
│   │   │   └── provider/
│   │   │       ├── CatalogApi.js
│   │   │       └── Provider.js
│   │   ├── templates/
│   │   │   ├── cityarea.dust
│   │   │   ├── firmCardAddr.dust
│   │   │   ├── firmCardContacts.dust
│   │   │   ├── firmCardHeader.dust
│   │   │   ├── firmCardRubric.dust
│   │   │   ├── firmCardSchedule.dust
│   │   │   ├── firmlistItem.dust
│   │   │   ├── frimCardPayments.dust
│   │   │   ├── house.dust
│   │   │   ├── loader.dust
│   │   │   ├── popupFooter.dust
│   │   │   ├── popupFooterBtns.dust
│   │   │   ├── popupHeader.dust
│   │   │   └── sight.dust
│   │   └── test/
│   │       ├── CatalogApiSpec.js
│   │       ├── ControllerSpec.js
│   │       └── GeoclickerSpec.js
│   ├── DGLabel/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── skin/
│   │   │   ├── basic/
│   │   │   │   └── less/
│   │   │   │       └── dg-label.less
│   │   │   ├── dark/
│   │   │   │   └── less/
│   │   │   │       └── dg-label.less
│   │   │   └── light/
│   │   │       └── less/
│   │   │           └── dg-label.less
│   │   ├── src/
│   │   │   ├── DGLabel.Layer.js
│   │   │   ├── DGLabel.js
│   │   │   ├── Entrance.DGLabel.js
│   │   │   ├── Marker.DGLabel.js
│   │   │   └── Path.DGLabel.js
│   │   └── test/
│   │       └── DGLabelSpec.js
│   ├── DGLocale/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── src/
│   │   │   ├── DGDictionary.js
│   │   │   └── DGLocale.js
│   │   └── test/
│   │       └── DGLocaleSpec.js
│   ├── DGLocation/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── lang/
│   │   │   ├── ar.js
│   │   │   ├── cs.js
│   │   │   ├── en.js
│   │   │   ├── es.js
│   │   │   ├── it.js
│   │   │   └── ru.js
│   │   ├── skin/
│   │   │   ├── basic/
│   │   │   │   └── less/
│   │   │   │       ├── dg-control-round.less
│   │   │   │       └── dg-location.less
│   │   │   ├── dark/
│   │   │   │   └── less/
│   │   │   │       └── dg-control-round.less
│   │   │   └── light/
│   │   │       └── less/
│   │   │           └── dg-control-round.less
│   │   ├── src/
│   │   │   └── DGLocation.js
│   │   └── test/
│   │       └── DGLocationSpec.js
│   ├── DGMeta/
│   │   ├── src/
│   │   │   ├── DGMeta.Layer.js
│   │   │   └── DGMeta.Origin.js
│   │   └── test/
│   │       ├── DGMetaSpec.js
│   │       └── PolyUtilContainsSpec.js
│   ├── DGMuseum/
│   │   ├── skin/
│   │   │   └── basic/
│   │   │       └── less/
│   │   │           └── dg-museum.less
│   │   └── src/
│   │       └── DGMuseum.js
│   ├── DGPoi/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── src/
│   │   │   └── DGPoi.js
│   │   └── test/
│   │       └── DGPoiSpec.js
│   ├── DGPopup/
│   │   ├── skin/
│   │   │   ├── basic/
│   │   │   │   ├── less/
│   │   │   │   │   ├── dg-popup.less
│   │   │   │   │   ├── leaflet.ie.less
│   │   │   │   │   ├── leaflet.less
│   │   │   │   │   └── scroller.less
│   │   │   │   └── skin.config.js
│   │   │   ├── dark/
│   │   │   │   └── less/
│   │   │   │       ├── dg-popup.less
│   │   │   │       ├── leaflet.ie.less
│   │   │   │       ├── leaflet.less
│   │   │   │       └── scroller.less
│   │   │   └── light/
│   │   │       └── less/
│   │   │           ├── dg-popup.less
│   │   │           ├── leaflet.ie.less
│   │   │           ├── leaflet.less
│   │   │           └── scroller.less
│   │   ├── src/
│   │   │   └── DGPopup.js
│   │   └── test/
│   │       └── DGPopupSpec.js
│   ├── DGProjectDetector/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── src/
│   │   │   └── DGProjectDetector.js
│   │   └── test/
│   │       ├── ProjectDetectorInSpec.js
│   │       ├── ProjectDetectorInitSpec.js
│   │       ├── ProjectDetectorOutOfWorldSpec.js
│   │       └── ProjectDetectorUnderSpec.js
│   ├── DGRoundControl/
│   │   ├── skin/
│   │   │   ├── basic/
│   │   │   │   └── less/
│   │   │   │       └── dg-control-round.less
│   │   │   ├── dark/
│   │   │   │   └── less/
│   │   │   │       └── dg-control-round.less
│   │   │   └── light/
│   │   │       └── less/
│   │   │           └── dg-control-round.less
│   │   ├── src/
│   │   │   └── DGRoundControl.js
│   │   └── test/
│   │       └── DGRoundControlSpec.js
│   ├── DGRuler/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── lang/
│   │   │   ├── ar.js
│   │   │   ├── cs.js
│   │   │   ├── en.js
│   │   │   ├── es.js
│   │   │   ├── it.js
│   │   │   └── ru.js
│   │   ├── skin/
│   │   │   └── basic/
│   │   │       └── less/
│   │   │           ├── dg-ruler.ie.less
│   │   │           └── dg-ruler.less
│   │   ├── src/
│   │   │   ├── GeometryStyles.js
│   │   │   ├── LayeredMarker.js
│   │   │   └── Ruler.js
│   │   └── test/
│   │       └── RulerSpec.js
│   ├── DGRulerControl/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── lang/
│   │   │   ├── ar.js
│   │   │   ├── cs.js
│   │   │   ├── en.js
│   │   │   ├── es.js
│   │   │   ├── it.js
│   │   │   └── ru.js
│   │   ├── skin/
│   │   │   └── basic/
│   │   │       └── less/
│   │   │           └── dg-control-round.less
│   │   ├── src/
│   │   │   └── Control.Ruler.js
│   │   └── test/
│   │       └── DGRulerControlSpec.js
│   ├── DGTraffic/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── lang/
│   │   │   ├── ar.js
│   │   │   ├── cs.js
│   │   │   ├── en.js
│   │   │   ├── es.js
│   │   │   ├── it.js
│   │   │   └── ru.js
│   │   ├── src/
│   │   │   └── DGTraffic.js
│   │   └── test/
│   │       └── DGTrafficSpec.js
│   ├── DGTrafficControl/
│   │   ├── demo/
│   │   │   └── index.html
│   │   ├── lang/
│   │   │   ├── ar.js
│   │   │   ├── cs.js
│   │   │   ├── en.js
│   │   │   ├── es.js
│   │   │   ├── it.js
│   │   │   └── ru.js
│   │   ├── skin/
│   │   │   └── basic/
│   │   │       └── less/
│   │   │           ├── dg-control-round.less
│   │   │           ├── dg-traffic-control.ie.less
│   │   │           └── dg-traffic-control.less
│   │   ├── src/
│   │   │   └── Control.Traffic.js
│   │   └── test/
│   │       └── TrafficControlSpec.js
│   ├── DGWkt/
│   │   ├── DGWkt.js
│   │   ├── demo/
│   │   │   └── index.html
│   │   └── test/
│   │       ├── DGWktSpec.js
│   │       ├── DGWktToGeoJSONSpec.js
│   │       └── DGWktToLatLngsSpec.js
│   ├── DGZoomControl/
│   │   ├── lang/
│   │   │   ├── ar.js
│   │   │   ├── cs.js
│   │   │   ├── en.js
│   │   │   ├── es.js
│   │   │   ├── it.js
│   │   │   └── ru.js
│   │   ├── skin/
│   │   │   ├── basic/
│   │   │   │   └── less/
│   │   │   │       └── dg-zoom-control.less
│   │   │   ├── dark/
│   │   │   │   └── less/
│   │   │   │       └── dg-zoom-control.less
│   │   │   └── light/
│   │   │       └── less/
│   │   │           └── dg-zoom-control.less
│   │   ├── src/
│   │   │   └── DGZoomControl.js
│   │   └── test/
│   │       └── DGZoomControlSpec.js
│   ├── copyright.js
│   ├── doc/
│   │   ├── en/
│   │   │   ├── examples/
│   │   │   │   ├── base.md
│   │   │   │   ├── bounds.md
│   │   │   │   ├── controls.md
│   │   │   │   ├── events.md
│   │   │   │   ├── external-modules.md
│   │   │   │   ├── geojson.md
│   │   │   │   ├── markers.md
│   │   │   │   ├── popups.md
│   │   │   │   ├── vector-layers.md
│   │   │   │   └── wkt.md
│   │   │   ├── manual/
│   │   │   │   ├── base-classes.md
│   │   │   │   ├── basic-types.md
│   │   │   │   ├── controls.md
│   │   │   │   ├── dg-ajax.md
│   │   │   │   ├── dg-entrance.md
│   │   │   │   ├── dg-external-modules.md
│   │   │   │   ├── dg-label.md
│   │   │   │   ├── dg-loading.md
│   │   │   │   ├── dg-locale.md
│   │   │   │   ├── dg-metalayers.md
│   │   │   │   ├── dg-project-detector.md
│   │   │   │   ├── dg-ruler.md
│   │   │   │   ├── dg-traffic.md
│   │   │   │   ├── dg-wkt.md
│   │   │   │   ├── dom-utils.md
│   │   │   │   ├── map.md
│   │   │   │   ├── markers.md
│   │   │   │   ├── other-layers.md
│   │   │   │   ├── popup.md
│   │   │   │   ├── raster-layers.md
│   │   │   │   ├── utils.md
│   │   │   │   └── vector-layers.md
│   │   │   └── quickstart/
│   │   │       └── quickstart.md
│   │   └── ru/
│   │       ├── examples/
│   │       │   ├── base.md
│   │       │   ├── bounds.md
│   │       │   ├── controls.md
│   │       │   ├── events.md
│   │       │   ├── external-modules.md
│   │       │   ├── geojson.md
│   │       │   ├── markers.md
│   │       │   ├── popups.md
│   │       │   ├── vector-layers.md
│   │       │   └── wkt.md
│   │       ├── manual/
│   │       │   ├── base-classes.md
│   │       │   ├── basic-types.md
│   │       │   ├── controls.md
│   │       │   ├── dg-ajax.md
│   │       │   ├── dg-entrance.md
│   │       │   ├── dg-external-modules.md
│   │       │   ├── dg-label.md
│   │       │   ├── dg-loading.md
│   │       │   ├── dg-locale.md
│   │       │   ├── dg-metalayers.md
│   │       │   ├── dg-migration.md
│   │       │   ├── dg-project-detector.md
│   │       │   ├── dg-ruler.md
│   │       │   ├── dg-traffic.md
│   │       │   ├── dg-wkt.md
│   │       │   ├── dom-utils.md
│   │       │   ├── map.md
│   │       │   ├── markers.md
│   │       │   ├── other-layers.md
│   │       │   ├── popup.md
│   │       │   ├── raster-layers.md
│   │       │   ├── utils.md
│   │       │   └── vector-layers.md
│   │       └── quickstart/
│   │           └── quickstart.md
│   ├── less/
│   │   ├── images-usage-statistics.less
│   │   ├── mixins.ie8.less
│   │   ├── mixins.images-usage-statistics.less
│   │   └── mixins.less
│   └── menu.json
├── test/
│   ├── after.js
│   ├── excludedTests.js
│   ├── karma.conf.js
│   └── test.js
└── vendors/
    ├── baron/
    │   ├── Gruntfile.js
    │   ├── baron.css
    │   ├── baron.js
    │   ├── changelog.md
    │   ├── demo/
    │   │   ├── baron.full.js
    │   │   ├── index.html
    │   │   ├── script.js
    │   │   └── style.css
    │   ├── js/
    │   │   ├── bean.js
    │   │   ├── bonzo.js
    │   │   ├── jquery-1.9.0.js
    │   │   └── qwery.js
    │   ├── package.json
    │   ├── readme.md
    │   ├── src/
    │   │   ├── controls.js
    │   │   ├── core.js
    │   │   ├── fix.js
    │   │   ├── pull.js
    │   │   └── test.js
    │   ├── tasks/
    │   │   └── mocha-phantomjs.js
    │   └── test/
    │       ├── core.auto.html
    │       ├── index.html
    │       ├── script.js
    │       ├── style.css
    │       └── tests.js
    ├── firmcard/
    │   ├── doc/
    │   │   └── Schedule.md
    │   ├── src/
    │   │   ├── Dictionary.js
    │   │   ├── FirmCard.DataHelper.js
    │   │   ├── FirmCard.js
    │   │   ├── FirmList.js
    │   │   ├── Schedule.js
    │   │   └── vendors/
    │   │       ├── momentjs/
    │   │       │   └── lang/
    │   │       │       ├── moment.cs.js
    │   │       │       ├── moment.it.js
    │   │       │       └── moment.ru.js
    │   │       └── underscore1.5.1.js
    │   └── test/
    │       ├── FirmCardSpec.html
    │       ├── FirmCardSpec.js
    │       ├── FirmListSpec.html
    │       ├── FirmListSpec.js
    │       ├── demoData.js
    │       ├── expect.js
    │       ├── mocha.css
    │       ├── mocha.js
    │       └── sinon.js
    └── polyfills/
        ├── es5.js
        └── promise.js

================================================
FILE CONTENTS
================================================

================================================
FILE: .csscomb.json
================================================
{
    "always-semicolon": true,
    "block-indent": false,
    "color-case": "lower",
    "color-shorthand": true,
    "element-case": false,
    "eof-newline": false,
    "leading-zero": false,
    "quotes": "single",
    "space-after-colon": false,
    "space-after-combinator": " ",
    "space-after-opening-brace": false,
    "space-after-selector-delimiter": false,
    "space-before-closing-brace": false,
    "space-before-colon": "",
    "space-before-combinator": " ",
    "space-before-opening-brace": false,
    "space-before-selector-delimiter": "",
    "space-between-declarations": false,
    "strip-spaces": true,
    "unitless-zero": true,
    "vendor-prefix-align": false,

    "sort-order": [[
        "position",
        "top",
        "right",
        "bottom",
        "left",
        "z-index",
        "display",
        "visibility",
        "-webkit-flex-direction",
        "-moz-flex-direction",
        "-ms-flex-direction",
        "-o-flex-direction",
        "flex-direction",
        "-webkit-flex-order",
        "-moz-flex-order",
        "-ms-flex-order",
        "-o-flex-order",
        "flex-order",
        "-webkit-flex-pack",
        "-moz-flex-pack",
        "-ms-flex-pack",
        "-o-flex-pack",
        "flex-pack",
        "float",
        "clear",
        "-webkit-flex-align",
        "-moz-flex-align",
        "-ms-flex-align",
        "-o-flex-align",
        "flex-align",
        "overflow",
        "-ms-overflow-x",
        "-ms-overflow-y",
        "overflow-x",
        "overflow-y",
        "-webkit-overflow-scrolling",
        "clip",
        "-webkit-box-sizing",
        "-moz-box-sizing",
        "box-sizing",
        "margin",
        "margin-top",
        "margin-right",
        "margin-bottom",
        "margin-left",
        "padding",
        "padding-top",
        "padding-right",
        "padding-bottom",
        "padding-left",
        "min-width",
        "min-height",
        "max-width",
        "max-height",
        "width",
        "height",
        "outline",
        "outline-width",
        "outline-style",
        "outline-color",
        "outline-offset",
        "border",
        "border-spacing",
        "border-collapse",
        "border-width",
        "border-style",
        "border-color",
        "border-top",
        "border-top-width",
        "border-top-style",
        "border-top-color",
        "border-right",
        "border-right-width",
        "border-right-style",
        "border-right-color",
        "border-bottom",
        "border-bottom-width",
        "border-bottom-style",
        "border-bottom-color",
        "border-left",
        "border-left-width",
        "border-left-style",
        "border-left-color",
        "-webkit-border-radius",
        "-moz-border-radius",
        "border-radius",
        "-webkit-border-top-left-radius",
        "-moz-border-radius-topleft",
        "border-top-left-radius",
        "-webkit-border-top-right-radius",
        "-moz-border-radius-topright",
        "border-top-right-radius",
        "-webkit-border-bottom-right-radius",
        "-moz-border-radius-bottomright",
        "border-bottom-right-radius",
        "-webkit-border-bottom-left-radius",
        "-moz-border-radius-bottomleft",
        "border-bottom-left-radius",
        "-webkit-border-image",
        "-moz-border-image",
        "-o-border-image",
        "border-image",
        "-webkit-border-image-source",
        "-moz-border-image-source",
        "-o-border-image-source",
        "border-image-source",
        "-webkit-border-image-slice",
        "-moz-border-image-slice",
        "-o-border-image-slice",
        "border-image-slice",
        "-webkit-border-image-width",
        "-moz-border-image-width",
        "-o-border-image-width",
        "border-image-width",
        "-webkit-border-image-outset",
        "-moz-border-image-outset",
        "-o-border-image-outset",
        "border-image-outset",
        "-webkit-border-image-repeat",
        "-moz-border-image-repeat",
        "-o-border-image-repeat",
        "border-image-repeat",
        "-webkit-border-top-image",
        "-moz-border-top-image",
        "-o-border-top-image",
        "border-top-image",
        "-webkit-border-right-image",
        "-moz-border-right-image",
        "-o-border-right-image",
        "border-right-image",
        "-webkit-border-bottom-image",
        "-moz-border-bottom-image",
        "-o-border-bottom-image",
        "border-bottom-image",
        "-webkit-border-left-image",
        "-moz-border-left-image",
        "-o-border-left-image",
        "border-left-image",
        "-webkit-border-corner-image",
        "-moz-border-corner-image",
        "-o-border-corner-image",
        "border-corner-image",
        "-webkit-border-top-left-image",
        "-moz-border-top-left-image",
        "-o-border-top-left-image",
        "border-top-left-image",
        "-webkit-border-top-right-image",
        "-moz-border-top-right-image",
        "-o-border-top-right-image",
        "border-top-right-image",
        "-webkit-border-bottom-right-image",
        "-moz-border-bottom-right-image",
        "-o-border-bottom-right-image",
        "border-bottom-right-image",
        "-webkit-border-bottom-left-image",
        "-moz-border-bottom-left-image",
        "-o-border-bottom-left-image",
        "border-bottom-left-image",
        "background",
        "filter:progid:DXImageTransform.Microsoft.AlphaImageLoader",
        "background-color",
        "background-image",
        "background-attachment",
        "background-position",
        "-ms-background-position-x",
        "-ms-background-position-y",
        "background-position-x",
        "background-position-y",
        "-webkit-background-clip",
        "-moz-background-clip",
        "background-clip",
        "background-origin",
        "-webkit-background-size",
        "-moz-background-size",
        "-o-background-size",
        "background-size",
        "background-repeat",
        "box-decoration-break",
        "-webkit-box-shadow",
        "-moz-box-shadow",
        "box-shadow",
        "color",
        "table-layout",
        "caption-side",
        "empty-cells",
        "list-style",
        "list-style-position",
        "list-style-type",
        "list-style-image",
        "quotes",
        "content",
        "counter-increment",
        "counter-reset",
        "-ms-writing-mode",
        "vertical-align",
        "text-align",
        "-webkit-text-align-last",
        "-moz-text-align-last",
        "-ms-text-align-last",
        "text-align-last",
        "text-decoration",
        "text-emphasis",
        "text-emphasis-position",
        "text-emphasis-style",
        "text-emphasis-color",
        "text-indent",
        "-ms-text-justify",
        "text-justify",
        "text-outline",
        "text-transform",
        "text-wrap",
        "-ms-text-overflow",
        "text-overflow",
        "text-overflow-ellipsis",
        "text-overflow-mode",
        "text-shadow",
        "white-space",
        "word-spacing",
        "-ms-word-wrap",
        "word-wrap",
        "-ms-word-break",
        "word-break",
        "-moz-tab-size",
        "-o-tab-size",
        "tab-size",
        "-webkit-hyphens",
        "-moz-hyphens",
        "hyphens",
        "letter-spacing",
        "font",
        "font-weight",
        "font-style",
        "font-variant",
        "font-size-adjust",
        "font-stretch",
        "font-size",
        "font-family",
        "src",
        "line-height",
        "opacity",
        "-ms-filter:\\'progid:DXImageTransform.Microsoft.Alpha",
        "filter:progid:DXImageTransform.Microsoft.Alpha(Opacity",
        "-ms-interpolation-mode",
        "-webkit-filter",
        "-ms-filter",
        "filter",
        "resize",
        "cursor",
        "nav-index",
        "nav-up",
        "nav-right",
        "nav-down",
        "nav-left",
        "-webkit-transition",
        "-moz-transition",
        "-ms-transition",
        "-o-transition",
        "transition",
        "-webkit-transition-delay",
        "-moz-transition-delay",
        "-ms-transition-delay",
        "-o-transition-delay",
        "transition-delay",
        "-webkit-transition-timing-function",
        "-moz-transition-timing-function",
        "-ms-transition-timing-function",
        "-o-transition-timing-function",
        "transition-timing-function",
        "-webkit-transition-duration",
        "-moz-transition-duration",
        "-ms-transition-duration",
        "-o-transition-duration",
        "transition-duration",
        "-webkit-transition-property",
        "-moz-transition-property",
        "-ms-transition-property",
        "-o-transition-property",
        "transition-property",
        "-webkit-transform",
        "-moz-transform",
        "-ms-transform",
        "-o-transform",
        "transform",
        "-webkit-transform-origin",
        "-moz-transform-origin",
        "-ms-transform-origin",
        "-o-transform-origin",
        "transform-origin",
        "-webkit-animation",
        "-moz-animation",
        "-ms-animation",
        "-o-animation",
        "animation",
        "-webkit-animation-name",
        "-moz-animation-name",
        "-ms-animation-name",
        "-o-animation-name",
        "animation-name",
        "-webkit-animation-duration",
        "-moz-animation-duration",
        "-ms-animation-duration",
        "-o-animation-duration",
        "animation-duration",
        "-webkit-animation-play-state",
        "-moz-animation-play-state",
        "-ms-animation-play-state",
        "-o-animation-play-state",
        "animation-play-state",
        "-webkit-animation-timing-function",
        "-moz-animation-timing-function",
        "-ms-animation-timing-function",
        "-o-animation-timing-function",
        "animation-timing-function",
        "-webkit-animation-delay",
        "-moz-animation-delay",
        "-ms-animation-delay",
        "-o-animation-delay",
        "animation-delay",
        "-webkit-animation-iteration-count",
        "-moz-animation-iteration-count",
        "-ms-animation-iteration-count",
        "-o-animation-iteration-count",
        "animation-iteration-count",
        "-webkit-animation-direction",
        "-moz-animation-direction",
        "-ms-animation-direction",
        "-o-animation-direction",
        "animation-direction",
        "pointer-events",
        "unicode-bidi",
        "direction",
        "-webkit-columns",
        "-moz-columns",
        "columns",
        "-webkit-column-span",
        "-moz-column-span",
        "column-span",
        "-webkit-column-width",
        "-moz-column-width",
        "column-width",
        "-webkit-column-count",
        "-moz-column-count",
        "column-count",
        "-webkit-column-fill",
        "-moz-column-fill",
        "column-fill",
        "-webkit-column-gap",
        "-moz-column-gap",
        "column-gap",
        "-webkit-column-rule",
        "-moz-column-rule",
        "column-rule",
        "-webkit-column-rule-width",
        "-moz-column-rule-width",
        "column-rule-width",
        "-webkit-column-rule-style",
        "-moz-column-rule-style",
        "column-rule-style",
        "-webkit-column-rule-color",
        "-moz-column-rule-color",
        "column-rule-color",
        "break-before",
        "break-inside",
        "break-after",
        "page-break-before",
        "page-break-inside",
        "page-break-after",
        "orphans",
        "widows",
        "-ms-zoom",
        "zoom",
        "max-zoom",
        "min-zoom",
        "user-zoom",
        "orientation",
        "..."
    ]]
}


================================================
FILE: .editorconfig
================================================
# EditorConfig: https://EditorConfig.org

root = true

[*]
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true

[*.{js,ts,jsx,tsx,json,html,css,md,yml}]
charset = utf-8

[*.{js,ts,jsx,tsx,json,html,css}]
indent_style = space
indent_size = 4

[*.yml]
indent_style = space
indent_size = 2


================================================
FILE: .eslintrc
================================================
{
  "extends": "eslint:recommended",
  "rules": {
    "eqeqeq": 0,
    "camelcase": 2,
    "quotes": [2, "single"],
    "no-mixed-spaces-and-tabs": [2, "smart-tabs"],
    "space-before-function-paren": [2, "never"],
    "space-in-parens": 2,
    "object-curly-spacing": 2,
    "array-bracket-spacing": 2,
    "computed-property-spacing": 2,
    "space-before-blocks": 2,
    "keyword-spacing": 2,
    "no-lonely-if": 2,
    "comma-style": 2,
    "indent": [2, 4, {"SwitchCase": 1}],
    "no-underscore-dangle": 0,
    "no-use-before-define": 0,
    "no-constant-condition": 0,
    "no-multi-spaces": 0,
    "strict": 0,
    "key-spacing": 0,
    "no-shadow": 0,
    "no-console": 1,
    "no-useless-escape": 0,
    "no-prototype-builtins": 0
  },
  "globals": {
    "DG": true,
    "L": true,
    "baron": true,
    "Promise": true
  },
  "env": {
    "browser": true,
    "node": true
  }
}


================================================
FILE: .github/workflows/test.yml
================================================
name: Test
on: push

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout 🛎️
        uses: actions/checkout@v2

      - name: Set env var to fix the PhantomJS error
        run: |
          echo "OPENSSL_CONF=/tmp/openssl.cnf" >> "$GITHUB_ENV"

      - name: Setup node 🔧
        uses: actions/setup-node@v2
        with:
          node-version: 12

      - name: Downgrade the Python version to fix the install errors
        uses: actions/setup-python@v5
        with:
          python-version: '3.10'

      - name: Test ✔️
        env:
          TEST_SECRET_KEY: ${{ secrets.TEST_SECRET_KEY }}
        run: |
          npm ci
          npm test


================================================
FILE: .gitignore
================================================
.DS_Store

.idea

node_modules
npm-debug.log

dist
gulp/tmp

.tern-port

config.local.json

nohup.out
vendors/leaflet/dist/leaflet-src.js

coverage
jsconfig.json
.vscode

yarn.lock


================================================
FILE: .npmignore
================================================
.DS_Store

.idea

node_modules
npm-debug.log

gulp/tmp

.tern-port

config.local.json

nohup.out
vendors/leaflet/dist/leaflet-src.js

coverage
jsconfig.json
.vscode

yarn.lock


================================================
FILE: CONTRIBUTING.md
================================================
## Содержание
1. [Как принять участие в развитии API карт](#Как-принять-участие-в-развитии-api-карт)
    * [Расскажите о нас](#Расскажите-о-нас)
    * [Сообщайте об ошибках](#Сообщайте-об-ошибках)
    * [Разрабатывайте собственные модули](#Разрабатывайте-собственные-модули)
    * [Участвуйте в исправлении ошибок](#Участвуйте-в-исправлении-ошибок)
    * [Участвуйте в улучшении документации](#Участвуйте-в-улучшении-документации)
2. [Как разработать собственный модуль](#Как-разработать-собственный-модуль)
    * [Инициализация](#Инициализация)
    * [Код модуля](#Код-модуля)
    * [Минификация и подключение](#Минификация-и-подключение)
    * [Прочие рекомендации](#Прочие-рекомендации)
3. [Как внести изменения в исходный код](#Как-внести-изменения-в-исходный-код)
4. [Установка локальной сборки API карт](#Установка-локальной-сборки-api-карт)
5. [Стандарты кодирования](#Стандарты-кодирования)
    * [JavaScript](#javascript)
    * [HTML и CSS](#html-и-css)

## Как принять участие в развитии API карт
Каждый из вас может повлиять на качество API карт и сделать продукт еще лучше. Ниже перечислено несколько способов того, как вы можете это сделать.
### Расскажите о нас
Реализовали качественный проект на API 2ГИС? Напишите об этом в своем блоге или социальной сети, поделитесь своим опытом использования API с другими разработчиками.
### Сообщайте об ошибках
Если вы нашли ошибку в работе API карт или столкнулись с проблемой, сообщите об этом на [форуме обратной связи](https://api2gis.uservoice.com) и мы обязательно поможем вам разобраться с проблемой. Как правило, хорошо локализованная ошибка — это уже половина работы по её исправлению, потому постарайтесь сделать максимально простой пример, на котором воспроизводится ошибка и разместите его в публичном доступе (например, используя [JSFiddle](http://jsfiddle.net/)), также не забудьте указать версию браузера и ОС, чтобы мы смогли воспроизвести ошибку.
### Разрабатывайте собственные модули
Вы можете расширять функциональность API карт под свои потребности при помощи модулей. Прочтите [небольшую инструкцию](#Как-разработать-собственный-модуль), которая поможет написать ваш первый модуль. Если считаете, что модуль будет полезен другим разработчикам, обязательно сообщите нам об этом по адресу api@2gis.ru, мы разместим информацию о нем на официальном сайте 2ГИС, а возможно и включим в базовую поставку API карт.

### Участвуйте в исправлении ошибок
Вы можете самостоятельно исправить найденные ошибки в работе API карт, для этого необходимо ознакомиться с [процессом внесения изменений в исходный код](#Как-внести-изменения-в-исходный-код) и прислать нам [pull request](https://help.github.com/articles/using-pull-requests).
### Участвуйте в улучшении документации
Если какой-то из разделов документации показался недостаточно полным и вы считаете, что его можно улучшить, вы можете сделать это самостоятельно. Для внесения изменений в документацию необходимо:
* найти интересующий вас раздел документации в папке [src/doc/](https://github.com/2gis/maps-api-2.0/tree/master/src/doc/manual) и открыть его содержимое;
* нажать кнопку Edit, отредактировать текст документации и нажать кнопку Propose File Change.

Мы рассмотрим ваш pull request с изменениями и при следующем релизе после их принятия они появятся на сайте API 2ГИС.

## Как разработать собственный модуль

Ниже приведен пример разработки простого модуля. С помощью этого модуля мы покажем, как расширить функционал API карт таким образом, чтобы у пользователей появилась возможность кликнуть в любой дом на карте и увидеть вокруг него магазины в радиусе 500 метров.

Перед началом разработки рекомендуется ознакомиться со [стандартами кодирования](#Стандарты-кодирования) и [документацией](http://api.2gis.ru/doc/maps/manual/loading/) API карт.

### Инициализация

Первое, что необходимо сделать — это создать отдельный [Github-репозиторий для нашего модуля](https://github.com/2gis/maps-api-2.0-plugin-demo).

И сформировать файловую структуру:

    /src   - исходные JS файлы
    /demo  - HTML файлы с примерами использования
    /dist  - минифицированные JS и CSS файлы, а также изображения
    README.md
    LICENSE.md

### Код модуля
Так как наш модуль довольно простой, он будет состоять всего из одного исходного JS файла, назовем его DGDemoPlugin.js и напишем в нем необходимый для работы код:
```javascript
    DG.DemoPlugin = DG.Handler.extend({

       _lastFirms: DG.layerGroup(),

       addHooks: function() {
           this._map.on('click', this._searchFirms, this);
       },

       removeHooks: function() {
           this._map.off('click', this._searchFirms, this);
       },

       _searchFirms: function(e) { // (MouseEvent)
           var latlng = e.latlng.wrap();

           DG.ajax({
               url: 'http://catalog.api.2gis.ru/2.0/search',
               data: {
                   what: 'магазин',
                   point: latlng.lng + ',' + latlng.lat,
                   radius: 500,
                   page_size: 50,
                   type: 'filial',
                   key: '12345678'
               },
               success: DG.bind(this._showFirms, this),
               error: DG.bind(this._logError, this)
           });
       },

       _showFirms: function(data) { // (Object)
           var firms, marker;

           if (data.response.code > 200) {
               this._logError(data);
               return;
           }

           this._lastFirms.clearLayers();

           firms = data.result.data;
           firms.forEach(function(firmInfo) {
               marker = DG.marker([firmInfo.geo.lat, firmInfo.geo.lon]);
               marker.bindPopup(firmInfo.firm.name);
               marker.addTo(this._lastFirms);
           }, this);

           this._lastFirms.addTo(this._map);
       },

       _logError: function(data) {
           console.log('Error: ', data);
       }
   });

   DG.Map.addInitHook('addHandler', 'demoPlugin', DG.DemoPlugin);
```

Наш модуль предполагает взаимодействие пользователя с картой, потому мы его отнаследовали от класса `DG.Handler`. Благодаря этому можно будет контролировать его поведение в процессе исполнения приложения (например, у разработчика будет возможность включить или выключить модуль).

Свойство `_lastFirms` представляет собой группу, в которую мы добавляем маркеры. В нашем случае это необходимо для того, чтоб можно было одной командой удалить с карты маркеры всех магазинов, которые были добавлены после предыдущего клика пользователя, и отобразить новые.

Методы `addHooks` и `removeHooks` срабатывает в тот момент, когда разработчик конечного приложения включает или отключает наш модуль.

Метод `_searchFirms` отправляет AJAX-запрос к [REST API справочника 2ГИС](http://catalog.api.2gis.ru/doc/2.0/catalog/filial/search-by-what-and-radius) и в случае успешного ответа вызывает метод `_showFirms`.

Метод `_showFirms` удаляет с карты все предыдущие маркеры и показывает новые.

Метод `_logError` при возникновении ошибки печатает в консоль браузера данные о ней.

Конструкция `DG.Map.addInitHook('addHandler', 'demoPlugin', DG.DemoPlugin)` позволяет карте зарегистрировать написанный нами обработчик пользовательских действий, после чего к нему можно будет обратиться по соответствующему имени, например:

    map.demoPlugin.enable();

### Минификация и подключение
Для минификации JS файлов существует множество популярных инструментов, вы можете воспользоваться любым из них, напрмиер [YUI Compressor](http://yui.github.io/yuicompressor/). Минифицированный JS файл необходимо положить в папку `dist` и предоставить к нему публичный доступ, после чего любой разработчик сможет подключить и использовать его вместе с API карт. Пример подключения модуля:

    DG.then(function() {
        //загрузка модуля
        return DG.plugin('https://raw.github.com/2gis/maps-api-2.0-plugin-demo/master/dist/DGDemoPlugin.js');
    })
    .then(function() {
        //инициализация карты
        var map = new DG.Map('map', {
            'center': new DG.LatLng(54.980206086231, 82.898068362003),
            'zoom': 15,
            'geoclicker': false
        });
        // включение модуля
        map.demoPlugin.enable();
    });

### Прочие рекомендации
Выше мы привели пример очень простого модуля, но модули могут быть более сложные, ниже перечислены некоторые рекомендации по их разработке.

Рекомендуемая файловая структура модуля:

    /src       — исходные JS файлы
    /doc       — документация
    /lang      — языковые файлы
    /skin      — изображения и CSS файлы разных тем API карт
    /templates — шаблоны
    /test      — тесты
    /demo      — HTML файлы с примерами использования
    /dist      — минифицированные JS и CSS файлы, а также изображения
    README.md
    LICENSE.md

В качестве примера модуля с описанной выше файловой структурой можно изучить [DGGeoclicker](https://github.com/2gis/maps-api-2.0/tree/master/src/DGGeoclicker).

Не забывайте снабжать модули тестами, это позволит упростить их поддержку в будущем. В качестве тестового фреймворка в API карт используется [Mocha](http://visionmedia.github.io/mocha/).

Делайте демонстрационные примеры. Как правило, это первое на что обращают внимание пользователи модуля при ознакомлении с его возможностями.

Составьте и положите в корневую папку модуля файл `README.md`, в котором будут описаны возможности модуля и примеры его использования.

Выберите лицензию для своего модуля, ведь это неотъемлемая часть любого open-source проекта. Такие ресурсы, как [tldrlegal.com](http://www.tldrlegal.com/) и [opensource.org](http://opensource.org/licenses) могут вам в этом помочь.

## Как внести изменения в исходный код
Для внесения изменений в существующий исходный код API карт (например, для исправления ошибки) вам потребуется:
* сделать [форк](https://help.github.com/articles/fork-a-repo) репозитория API карт;
* [установить API карт локально](#Установка-локальной-сборки-api-карт) на своем компьютере;
* сделать ветку, название которой будет соответствовать сути вашего изменения (ветку необходимо унаследовать от ветки `master`, так как в ней находится последняя стабильная версия API карт);
* внести свои изменения в код (рекомендуется следовать принятым [стандартам кодирования](#Стандарты-кодирования));
* прислать нам pull request.

После изучения и тестирования pull request-а мы его примем (возможно с некоторыми доработками), после чего они попадут в релиз и станут доступны всем пользователям API карт.

Пожалуйста, не забывайте покрывать и проверять измененный код тестами.

Для запуска тестов в PhantomJS (по умолчанию) необходимо из консоли выполнить команду:

    gulp test

Для запуска тестов в браузерах вашей операционной системы укажите названия браузеров с помощью параметров:

    gulp test --ff --chrome

Список доступных параметров:

    (default)   PhantomJS
    --chrome    Chrome
    --ff        Firefox
    --opera     Opera
    --safari    Safari
    --ie        IE (только для Windows)

Если вам необходимо выполнить тесты за несколько запусков браузера, то вы можете использовать параметр:
    
    --multiple-chunks
    
По умолчанию при каждом запуске браузера будут выполняться тесты из 10ти модулей.
Изменить это число можно параметром:

    --items-in-chunk

Также вы можете проверить код на наличие синтаксических ошибок, для этого необходимо выполнить команду:

    gulp lint

## Установка локальной сборки API карт
Ниже перечислены шаги, которые необходимо выполнить для установки API карт локально на своем компьютере.

* Склонируйте репозиторий:

        git clone git@github.com:2gis/mapsapi.git

    Примечание: если вы устанавливаете API карт не с текущего репозитория, а с его форка, тогда не забудьте указать первым параметром команды `clone` адрес форка вместо адреса репозитория 2ГИС.
* Установите [Node.js](https://nodejs.org/)
* Установите зависимости:

        cd ~/mapsapi-folder
        npm install

* В файле `config.main.json` замените параметр `baseUrl` на пустую строку: `"baseUrl": ""`.
* Выполните сборку API карт и запуск сервера:

        npm run dev

После выполнения описанных выше действий вы сможете открыть в браузере карту по адресу http://127.0.0.1:3000/2.0/

## Стандарты кодирования

### JavaScript
Основные требования к JavaScript коду обеспечиваются синтаксическим анализатором и описаны в конфигурационом файле [ESLint](https://github.com/2gis/maps-api-2.0/blob/master/.eslintrc). В процессе разработки мы стараемся придерживаться соглашений, схожими с [Airbnb style guide](https://github.com/airbnb/javascript), за исключением соглашений о [пробелах](https://github.com/airbnb/javascript#whitespace) и [комментариях](https://github.com/airbnb/javascript#comments).

### HTML и CSS
#### Определения
Данные соглашения — набор правил разной степени обязательности исполнения. Используется три степени:
* обязательно — нарушение правила не имеет смысла либо полностью запрещено. Нарушение должно обсуждаться заранее с командой;
* должно — нарушение правила возможно при достаточном обосновании. Нарушение можно обсудить постфактум или оставить комментарий в коде;
* рекомендуется — при прочих равных лучше использовать рекомендованный вариант.

Соглашения являются расширением методологии [БЭМ](http://ru.bem.info/method/definitions/), поэтому используются следующие термины:
* блок — синоним понятий «плагин», «модуль» — неразрывная независимая часть ветки DOM-дерева (или ветка целиком), и связанных с ней CSS-правил, которая может быть переиспользована на любом проекте, в любом контексте. Блоком так же называется корневой тег такой структуры;
* элемент — структурная единица блока. Элемент всегда принадлежит одной копии блока. Элемент не имеет смысла вне блока. Элемент не может принадлежать одновременно нескольким блокам, или нескольким копиям одного блока. При движении от элемента вверх по DOM дереву можно встретить любое число других элементов того же блока, либо сам блок. Нельзя встретить элементы других блоков или другие блоки;
* модификатор — синоним понятия «состояние». Модификатор реализует наследование блоков — когда нам нужен второй блок, очень похожий на первый. Модификатор всегда относится к какому-то конкретному блоку или элементу. У любого блока и элемента может быть несколько модификаторов, по несколько значений у каждого.

#### Область применения

Данное соглашение применяется для вновь создаваемых блоков (модулей). Сюда относится замена блока при рефакторинге. Соглашение имеет слабое влияние при небольших работах со старым кодом, а также при переиспользовании сторонних модулей.

#### HTML
* вёрстка должна быть [валидным](http://validator.w3.org/#validate_by_input+with_options) html5 кодом;
* код должен быть максимально семантичным;
* код должен быть в нижнем регистре;
* рекомендуется не указывать типы для тегов `script` и `link`;
* рекомендуется пропускать строку перед блоками, списками, таблицами и т.д.;
* должны использоваться двойные кавычки в атрибутах HTML.

##### Рекомендуется использовать теги html5
* `article` — выделение смысловой самостоятельной единицы (обычно блока);
* `address` — тег для адреса;
* `aside` — тег для сопутствующей информации, например «конкуренты»;
* `time` — тег для любого времени или даты;
* `header` и `footer` для явно выраженной шапки и футера блока, если такие есть;
* а также: `summary`, `nav` и другие.

Существующие теги и их назначение: http://www.w3.org/TR/html-markup/elements.html#elements

* рекомендуется использовать атрибуты [schema.org](http://schema.org/docs/gs.html#microdata_how);
* запрещено использовать «табличные» теги: `table`, `thead`, `tbody`, `tfoot`, `tr`, `th`, `td` кроме как по их прямому назначению — т.е. для отображения табличных данных;
* запрещено использование устаревших тегов: `font`, `blink` и прочее;
* у каждого тега, который будет иметь визуальное представление на странице, должен быть CSS-класс (полное покрытие тегов классами).

##### Структура
* должна использоваться методология БЭМ;
* любая визуальная HTML нода должна быть покрыта CSS-классом;
* структура HTML должна быть семантичной и минимально зависеть от дизайна. Иными словами, по HTML-коду должно быть всё понятно о содержимом страницы, но ничего не понятно о её дизайне.

Плохо:

    <div class="outer-wrapper">
        <div class="inner-wrapper">
            <div class="right clerafix">Какой-то <span class="red">текст</span></div>
        </div>
    </div>

Хорошо:

    <article class="dg-card dg-card_type_org dg-card_spec_edu" itemscope itemtype="http://schema.org/EducationalOrganization">
        <header class="dg-card__header">
            <h1 class="dg-card__name" itemprop="name">Школа №176</h1>
        </header>
        <address class="dg-card__address" itemprop="streetAddress">Красный проспект, д. 348</address>
    </article>

Приветствуется минимизация DOM-дерева (исключение различных оберток, оболочек, разделителей, однопиксельных GIF-файлов и т.п.).

##### Общий пример

    <div class="dg-board">
        <div class="dg-board__list">
            <div class="dg-filters">...</div>
            <article class="dg-card" itemscope itemtype="http://schema.org/EducationalOrganization">
                <header class="dg-card__header">
                    <h1 class="dg-card__name" itemprop="name">Школа №176</h1>
                </header>
                <address class="dg-card__address" itemprop="streetAddress">Красный проспект, д. 348</address>
            </article>
            <article class="dg-card">...</article>
            <article class="dg-card">...</article>
        </div>
    </div>

#### CSS
##### Именование классов
* обязательно используется методология БЭМ для именования всех CSS-классов;
* для блоков должен использоваться префикс .dg-, например: `.dg-fullscreen`;
* любой CSS-класс должен начинаться с имени блока;
* любой класс по своему предназначению и правилам составления имени должен быть блоком, элементом, или модификатором;
* модификатор обязан иметь четкое описание-комментарий;
* запрещено использовать в имени блока любые символы, кроме a-z, 0-9 и &laquo;-&raquo;, а в качестве первого символа любые, кроме a-z. То же касается составных частей элементов и модификаторов;
* должны использоваться одинарные кавычки;
* должны использоваться короткие 16-тиричные числа, когда это возможно (#ffffff → #fff);
* рекомендуется использовать сокращенные названия свойств CSS;
* не рекомендуется указывать единицы измерений после нулевых значений. Плохо: `margin: 0px 10px;` Хорошо: `margin: 0 10px;`.

Примеры классов блоков: `.dg-search`, `.dg-popup`, `.dg-card`, `.dg-firm-list`.

* имя любого элемента обязательно имеет префикс `.block__`, где &laquo;block&raquo;&nbsp;&mdash; имя блока, которому принадлежит этот элемент.

Примеры классов элементов: `.dg-card__name`, `.dg-search__query`, `.dg-popup__close`.

* имя модификатора обязательно имеет префикс `block_` или `block__elem_` и состоит из двух частей: имя модификатора и значение модификатора.

Примеры классов модификаторов:
* `.dg-card_type_firm`&nbsp;&mdash; тип карточки &laquo;фирма&raquo;;
* `.dg-search_mode_metro`&nbsp;&mdash; режим строки поиска &laquo;метро&raquo;;
* `.dg-popup_state_hidden`&nbsp;&mdash; состояние коллаута &laquo;скрыт&raquo;;
* `.dg-board__list_state_minimized`&nbsp;&mdash; состояние элемента &laquo;список&raquo; равно &laquo;свёрнут&raquo;.

Модификаторы:

* любой модификатор обязательно относится только к какому-то конкретному элементу или блоку;
* разрешено использовать несколько разных модификаторов блока или элемента одновременно (например `.dg-card_state_visible` и `.dg-card_type_building`);
* запрещено использовать несколько разных значений одного модификатора или элемента одновременно (например `.dg-card_state_hidden` и `.dg-card_state_visible`).

##### Селекторы
* селектор должен состоять только из одного имени класса;
* селекторы по тегам крайне не желательны;
* запрещено использовать селекторы по id;
* одно состояние одного селектора должно встречаться в CSS 0 или 1 раз;
* селекторы через запятую не желательны. Если такая необходимость сильно выражена, то стоит подумать о создании нового элемента с общими стилями, и его примешиванию к уже существующим в HTML коде;
* классы должны быть сгруппированы вокруг своего блока в порядке: блок, элементы, модификаторы блока. То есть, в потоке CSS одним выделением можно выделить все стили блока и его элементов;
* состояния класса должны быть также сгруппированы: класс, его псевдоклассы, его псевдоэлементы;
* модификаторы блока должны быть сгруппированы по названию модификатора и по его значениям;
* псевдоэлементы before и after должны отделяться от селектора одинарным двоеточием.

##### Свойства
* запрещено использование `!important`;
* стили, предназначенные для IE 8, должны находиться в отдельных файлах;
* файлы со стилями для IE 8 должны иметь суффикс &laquo;ie&raquo;. Пример: `dg-fullscreen.ie.less`;
* наличие невалидного CSS должно быть строго обосновано. Используем [CSS валидатор](http://jigsaw.w3.org/css-validator/#validate_by_input);
* любое неочевидное свойство или значение должно поясняться `/* комментарием */` на английском языке.


================================================
FILE: LICENSE
================================================
НАСТОЯЩИЙ ДОКУМЕНТ ЯВЛЯЕТСЯ ЮРИДИЧЕСКИМ ДОГОВОРОМ («Договор») между ООО «ДубльГИС» («Мы», «Нас»,
«2ГИС») И ВАМИ («Вы») В ОТНОШЕНИИ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ API («Программное обеспечение»).

КОГДА ВЫ СКАЧИВАЕТЕ, УСТАНАВЛИВАЕТЕ, КОПИРУЕТЕ ИЛИ ИНЫМ ОБРАЗОМ ИСПОЛЬЗУЕТЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ,
ВЫ ТЕМ САМЫМ ПРИНИМАЕТЕ УСЛОВИЯ ДОГОВОРА, ИЗЛОЖЕННЫЕ НИЖЕ. ЕСЛИ ВЫ НЕ СОГЛАСНЫ С НИЖЕСЛЕДУЮЩИМИ
УСЛОВИЯМИ, ВЫ НЕ ИМЕЕТЕ ПРАВА СКАЧИВАТЬ, УСТАНАВЛИВАТЬ, КОПИРОВАТЬ ИЛИ ИНЫМ ОБРАЗОМ ИСПОЛЬЗОВАТЬ
ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ИЛИ КАКУЮ-ЛИБО ЕГО ЧАСТЬ. НАСТОЯЩИЙ ЛИЦЕНЗИОННЫЙ ДОГОВОР ОПИСЫВАЕТ ВАШИ
ПРАВА И ОГРАНИЧЕНИЯ В ОТНОШЕНИИ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ И ЕГО КОМПОНЕНТОВ.

1. ОПРЕДЕЛЕНИЯ

«Приложение» означает любое программное обеспечение, приложение или элементы, которые Вы
«разрабатываете или которыми управляете, используя Программное обеспечение или Модификации в
«соответствии с настоящим Договором.

«Конечный пользователь» означает конечного пользователя Вашего Приложения, который приобрел лицензию
«на Приложение для собственного внутреннего использования, но не для распространения, перепродажи,
«разработки пользовательского интерфейса или иных целей, связанных с разработкой.

«Модификация» означает: а) любое дополнение или удаление из контента файла, включенного в
«первоначальную версию Программного обеспечения или предшествующие Модификации, созданные вами,
«и/или b) любой новый файл, который использует любую часть первоначальной версии Программного
«обеспечения или предшествующих Модификаций.

«Исходная» форма означает предпочтительную форму для внесения изменений, включая, в том числе,
«исходный код программного обеспечения, исходную документацию и конфигурационные файлы.

«Объектная» форма означает любую форму, полученную в результате механической трансформации или
«перевода из Исходной формы, включая, в том числе, скомпилированный объектный код, генерируемую
«документацию и конвертирование в иные форматы.

«Код счетчика посещений» означает часть Исходной формы, которая требуется для отслеживания,
«мониторинга и регистрации деятельности Конечных пользователей.

«Программное обеспечение API» (Программное обеспечение») означает программный интерфейс приложения
«ООО ДубльГИС»  версии 2.0 в форме, предоставляемой Вам ООО ДубльГИС», включая библиотеки, исходный
«код, документацию, набор инструментальных средств разработчика и иные материалы, размещаемый на
«https://github.com/2gis/maps-api-2.0 и http://api.2gis.ru/, предназначенный для модификаций,
«адаптаций и иных изменений программного обеспечения.

Программное обеспечение включает любые изменения, обновления, исправления ошибок или
модифицированные версии Программного обеспечения, при условии, что Мы имеем право изменять
Программное обеспечение, а также изменять или отзывать настоящую лицензию на использование
Программного обеспечения по Нашему исключительному усмотрению и в любое время без направления Вам
предварительного уведомления. Новая версия Договора вступает в силу в день ее размещения на сайте
http://law.2gis.ru, если иное не предусмотрено новой версией договора. В случае Вашего несогласия с
измененной или обновленной версией Программного обеспечения, применяется раздел 7 настоящего
Договора.

«Средства индивидуализации» означает в совокупности товарные знаки, торговые марки, знаки
«обслуживания, логотипы, уведомления об авторском праве, доменные имена ООО ДубльГИС», а также иные
«Наши средства индивидуализации.

«Базы данных» означает в совокупности, общедоступные размещаемые и принадлежащие ООО ДубльГИС» Базы
«данных электронных карт, включающие, в том числе, ГИС данные о географических объектах и населенных
«пунктах в пределах территории, ограниченной определенными географическими координатами.

 «Контент» означает данные, включая, в том числе, любые фрагменты информации, хранящиеся и/или
 «извлекаемые из Баз данных, и/или любые иные данные или информацию, которую ОООДубльГИС» включило в
 «свое Программное обеспечение. Использование Вами Контента ограничено одновременным использованием
 «Программного обеспечения.

 

2. ПРЕДОСТАВЛЕНИЕ ЛИЦЕНЗИИ

2.1. При условии соблюдения условий настоящего Договора, Мы предоставляем на срок защиты авторского
права, действующую по всему миру, неисключительную, бесплатную и не подлежащую сублицензированию
лицензию (i) Вам — на использование, копирование, модификацию, объединение Программного обеспечения
в исходной и объектной формах для создания Модификаций и Приложений; (ii) Вам — на публичный показ,
публичное исполнение и бесплатное распространение Конечным пользователям Программного обеспечения
и/или Модификаций в исходной или объектной форме, включенных в Приложения; и (iii) Конечным
пользователям — на использование Программного обеспечения, включенного в Ваши Приложения в
соответствии с условиями настоящего Договора; (iv) Вам — на право осуществления коммуникации между
Вашим Приложением и Базами данных и извлечение из Баз данных информации, необходимой для
использования способами, разрешенными настоящим Договором; (v) Вам — на изготовление ограниченного
числа промежуточных копий Контента исключительно для совершение действий, разрешенных настоящим
Договором, и на изменение (исключительно в целях реорганизации или упорядочивания) Контента в
пределах Приложения; (vi) Вам — на раскрытие для всеобщего ознакомления структуры Программного
обеспечения и Исходного кода, при условии, что Вы надлежащим образом идентифицируете их путем
использования Средств индивидуализации.

Мы сохраняем за собой право модифицировать, изменять, обновлять и/или улучшать Программное
обеспечение, Базы данных, Исходный код и Контент в любое время с уведомлением Вас или без такого
уведомления по Нашему исключительному усмотрению.

2.2. Вы можете модифицировать Исходный код исключительно в целях проектирования, разработки и
тестирования Ваших собственных Приложений. Тем не менее, Вам разрешается использовать, копировать,
воспроизводить, распространять и перераспределять Ваш модифицированный Исходный код при соблюдении
следующих условий: (a) Вы включаете Наше уведомление об авторском праве (его текст содержится в
Дополнении А к настоящему Договору) в Ваше Приложение, в том числе в любом месте, где в таком
Приложении появляется любое иное уведомление об авторском праве; и (b) Вы не используете иным
образом Наше наименование, Средства индивидуализации и иные Наши торговые марки для реализации
Вашего Приложения, кроме случаев когда Мы в письменном виде согласовали иное. Кроме случаев,
указанных выше, Вы не можете иным образом модифицировать, удалять или изменять Код счетчика
посещений, включенный в Программное обеспечение.

2.3. На Вас не возлагается обязанность по уплате Нам каких-либо роялти в за осуществляемое Вами
распространение Программного обеспечения в соответствии с настоящим Договором, а также по уплате Нам
каких-либо комиссий за использование или распространение Приложений в соответствии с настоящим
Договором.

3. ПРАВО СОБСТВЕННОСТИ

3.1. Настоящий Договор является лицензионным договором, а не договором купли- продажи. Мы сохраняем
за собой все права интеллектуальной собственности на Программное обеспечение или связанные с
Программным обеспечением, включая, в том числе, авторское право, патентные права, все права на
зарегистрированные и не зарегистрированные товарные знаки (знаки обслуживания), конфиденциальную
информацию (включая секреты производства и ноу-хау) и все иные права, кроме тех, которые в прямо
выраженной форме предоставляются по настоящему Договору.

3.2. Мы предоставляем Вам Исходный код, что позволяет Вам создавать Модификации и Приложения. В то
время как Вы сохраняете за собой все права на любые оригинальные произведения в составе Модификаций,
автором которых Вы являетесь, мы сохраняем все права авторства и интеллектуальной собственности в
отношении Программного обеспечения, Исходного кода, Баз данных, Контента, Кода счетчика посещений.

3.3. Вы не вправе удалять, скрывать или изменять любые уведомления об авторском праве,
удостоверения, ссылки на источник, товарные знаки, предупреждения или заявление об отказе от
ответственности, прикрепленные, включенные или иным образом применимые к Программному обеспечению.

4. ОБРАТНАЯ СВЯЗЬ

4.1. ООО «ДубльГИС» владеет бесплатной, действующей по всему миру, бессрочной лицензией на
использование и включение в состав Программного обеспечения или Контента любых предложений, идей,
заявок на расширение, откликов, рекомендаций и иной информации и ее производных, предоставляемых
Вами.

5. ЗАПРЕЩЕННОЕ ИСПОЛЬЗОВАНИЕ

5.1. Вы не вправе повторно распространять Программное обеспечение или Модификации иным образом,
кроме как путем включения Программного обеспечения или его части в Ваше Приложение. Вы не вправе
изменять или удалять уведомление об авторском праве с файлов, включенных в Программное обеспечение
или Модификации.

5.2. Разрешение по настоящему Договору предоставляется любому лицу на использование данного
Программного обеспечения для любой цели, исключая коммерческое использование, которое ограничивается
в соответствии с настоящим Договором. Программное обеспечение или Модификации должны использоваться
исключительно в составе Приложений, доступных для бесплатного общедоступного использования.
Использование Программного обеспечения или Модификаций для платных проектов или иных проектов,
предполагающих ограничение доступа Конечных пользователей к Базам данных и/или Контенту, строго
запрещается. В случае необходимости коммерческого использования, пожалуйста, обратитесь к Нам по
следующему адресу api@2gis.ru.

5.3. Версии Программного обеспечения с открытым кодом («GPL Версия») могут лицензироваться в
соответствии с Универсальной общедоступной лицензией версии 3.0., созданной в рамках проекта GNU
(«GPL»), а не в соответствии с настоящим Договором. Если Вы или иное третье лицо разработали
полностью (или любую часть) Приложения(ий), используя GPL Версию, Вы не вправе объединять такое
разработанное произведение с Программным обеспечением и обязаны лицензировать такое(ие)
Приложение(я) (или любую их часть) в соответствии с Универсальной общедоступной лицензией версии
3.0., созданной в рамках проекта GNU, с которой можно ознакомиться по адресу
http://www.gnu.org/copyleft/gpl.html.

6. ОГРАНИЧЕНИЯ

6.1. Кроме случаев, прямо разрешенных настоящим Договором, Лицензиат не вправе:

(i) использовать Программное обеспечение, Базы данных, Исходный код или Контент любым способом,
(который прямо не разрешен или не предоставлен по настоящему Договору;

(ii) копировать Контент для целей, лежащих вне сферы действия лицензии, предоставленной по
(настоящему Договору;

(iii) использовать Контент для создания баз данных или любых компиляций Контента без Нашего
(предварительного письменного разрешения;

(iv) распространять, публиковать, продвигать, предоставлять право или разрешать доступ или
(предоставлять ссылку на Контент или Базы данных из любого места или источника, кроме Вашего
(Приложения;

(v) использовать Контент для создания приложения, которое предлагает или рекламирует услуги, которые
(порочат Наши услуги, наносят ущерб или являются конкурирующими по отношению к Нашим услугам или
(иным образом вредят Нашим услугам;

(vi) обходить, устанавливать спайдеры и индексы или любым способом сохранять информацию, полученную
(из Контента кроме способов, предусмотренных настоящей ограниченной лицензией) или распространять
(любые вирусы, «червей», троянские программы или иные программы, направленные на причинение вреда
(любым системам или данным, отправлять или сохранять наносящие вред или незаконные материалы с
(использованием Программного обеспечения;

(vii) предоставлять Контент или Базы данных любым третьим сторонам способом, противоречащим условиям
(использования, предусмотренным для пользователей нашего сайта;

(viii) осуществлять коммерческое использование т.е. продавать, сдавать в аренду), копировать,
(хранить или кэшировать Контент или Базы данных для иных целей, кроме разрешенных настоящим
(Договором.

6.2. Ограничение сублицензирования. Кроме случаев, предусмотренных в настоящем разделе, все
лицензионные права (в соответствии с применимым правом интеллектуальной собственности),
предоставленные по настоящему Договору, не подлежат сублицензированию, передаче или уступке. При
условии соблюдения положений ниже, Вы вправе сублицензировать Ваше право на показ Контента и Средств
индивидуализации, как предусмотрено настоящим Договором, Конечным пользователям исключительно для
того, чтобы они имели возможность показа Контента и Средств индивидуализации на экранах своих
компьютеров и/или вебсайтах посредством Вашего Приложения.

7. ПРЕКРАЩЕНИЕ

7.1. Настоящий Договор и Ваше право на использование Программного обеспечения и Модификаций
немедленно прекращается в случае Вашего несоблюдения любых условий настоящего Договора. После
прекращения Вы должны немедленно прекратить использование и уничтожить Программное обеспечение и
Модификации, включая все сопроводительные документы.

8. ОТКАЗ ОТ ПРЕДОСТАВЛЕНИЯ ГАРАНТИЙ

8.1. В МАКСИМАЛЬНОЙ СТЕПЕНИ, ДОПУСТИМОЙ ПРИМЕНИМЫМ ЗАКОНОДАТЕЛЬСТВОМ, МЫ ОТКАЗЫВАЕМСЯ ОТ
ПРЕДОСТАВЛЕНИЯ ЛЮБЫХ ГАРАНТИЙ И УСЛОВИЙ, ПРЯМО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ, В ТОМ ЧИСЛЕ,
ПОДРАЗУМЕВАЕМЫЕ ГАРАНТИИ ПРИГОДНОСТИ ДЛЯ ПРОДАЖИ, ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННОЙ ЦЕЛИ, НАЛИЧИЯ ПРАВА
СОБСТВЕННОСТИ И ОТСУТСТВИЯ НАРУШЕНИЙ В ОТНОШЕНИИ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ. МЫ НЕ ГАРАНТИРУЕМ, ЧТО
РАБОТА ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ИЛИ ЕГО КОДА, БУДЕТ БЕСПЕРЕБОЙНОЙ И БЕЗОШИБОЧНОЙ, И ВЫ ПРИЗНАЕТЕ,
ЧТО ПРЕДОСТАВЛЕНИЕ ТАКИХ ГАРАНТИЙ ЯВЛЯЕТСЯ ТЕХНИЧЕСКИ НЕОСУЩЕСТВИМЫМ ДЛЯ НАС.

9. ОГРАНИЧЕНИЕ ОТВЕТСТВЕННОСТИ

9.1. В МАКСИМАЛЬНОЙ СТЕПЕНИ, ДОПУСТИМОЙ ПРИМЕНИМЫМ ЗАКОНОДАТЕЛЬСТВОМ, МЫ НИ ПРИ КАКИХ
ОБСТОЯТЕЛЬСТВАХ НЕ ОТВЕЧАЕМ, НА ОСНОВАНИИ КАКИХ-ЛИБО ЗАКОНОВ, ЗА ЛЮБЫЕ ОСОБЫЕ, СЛУЧАЙНЫЕ, КОСВЕННЫЕ
ИЛИ ВТОРИЧНЫЕ УБЫТКИ (ВКЛЮЧАЯ, В ТОМ ЧИСЛЕ, УБЫТКИ В ФОРМЕ УПУЩЕННОЙ ВЫГОДЫ, ПРИОСТАНОВЛЕНИЯ
ДЕЯТЕЛЬНОСТИ, ПОТЕРИ КОММЕРЧЕСКОЙ ИНФОРМАЦИИ ИЛИ ЛЮБОЙ ИНОЙ ИМУЩЕСТВЕННЫЙ УЩЕРБ), ВОЗНИКШИЕ В
РЕЗУЛЬТАТЕ ИСПОЛЬЗОВАНИЯ ИЛИ НЕВОЗМОЖНОСТИ ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ИЛИ ЕГО КОДА, ИЛИ
ПО ЛЮБОЙ ПРИЧИНЕ, СВЯЗАННОЙ С ПРЕДМЕТОМ НАСТОЯЩЕГО ДОГОВОРА, ДАЖЕ В СЛУЧАЕ ЕСЛИ МЫ БЫЛИ
ПРЕДУПРЕЖДЕНЫ О ВОЗМОЖНОСТИ ВОЗНИКНОВЕНИЯ ТАКИХ УБЫТКОВ.

10. БЕСПЛАТНОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ

10.1. Независимо от указанного выше, Мы признаем, что некоторые компоненты Программного обеспечения
могут подпадать под действие лицензии на так называемое «программное обеспечение с открытым исходным
кодом» («Компоненты с открытым кодом»). Мы обязуемся подготовить обзор соответствующего бесплатного
программного обеспечения и предоставить Вам полный соответствующий исходный код, включая все
изменения, произведенные нами (при наличии). Обзор будет включен в Дополнение А, вместе с копией
условий лицензии, регулирующих предоставление соответствующего бесплатного программного обеспечения.

10.2. В степени, требуемой лицензиями, касающимися Компонентов с открытым кодом, условия таких
лицензий будут применяться вместо условий настоящего Договора, и мы настоящим заявляем, что только
Компоненты с открытым кодом, лицензируемые на основании лицензий, предоставляющих объем прав не уже,
чем лицензия, предоставляемая по настоящему Договору, включены в Программное обеспечение. В той
мере, в какой лицензии, применимые в отношении Компонентов с открытым кодом, запрещают какие-либо
ограничения, содержащиеся в настоящем Договоре, такие ограничения не будут применяться в отношении
Компонентов.

11. ИНТЕЛЛЕКТУАЛЬНАЯ СОБСТВЕННОСТЬ

11.1. Программное обеспечение содержит Наши товарные знаки, логотипы, патенты, секреты производства
и/или материалы, охраняемые авторским правом. Вы обязуетесь не раскрывать и не предоставлять такие
секреты производства и/или ноу-хау в любой форме любым третьим сторонам, не удалять уведомления о
товарных знаках, уведомления об авторском праве, условия лицензии с Программного обеспечения или
любых его компонентов. Право собственности и права интеллектуальной собственности на Наши товарные
знаки или в отношении Наших товарных знаков и материалов, охраняемых авторским правом, которые
отображаются или доступны посредством Программного обеспечения, принадлежат нам.

11.2. При условии соблюдения положений настоящего Договора и на период действия Договора Мы
предоставляем Вам ограниченную, неисключительную, отзывную, сублицензируемую лицензию на отображение
товарных знаков, торговых марок, знаков обслуживания, логотипов, уведомлений об авторских правах,
доменных имен и иных Средств индивидуализации в соответствии с настоящим Договором и исключительно в
целях указания на источник Программного обеспечения и для продвижения и/или рекламирования того
факта, что Вы используете Программное обеспечение в Вашем Приложении, разработанном на его основе.

11.3. Никогда, в течение срока действия настоящего Договора или после его завершения, Вы не вправе
оспаривать права на Средства индивидуализации или содействовать другим лицам в оспаривании таких
прав, а также не вправе содействовать в регистрации любых Средств индивидуализации или
опознавательных черт бренда (включая доменные имена), которые в любом виде схожи до степени смешения
в любыми Средствами индивидуализации.

12. ГАРАНТИИ СТОРОН В ОТНОШЕНИИ ВОЗМЕЩЕНИЯ УБЫТКОВ

12.1. При условии соблюдения положений настоящего Договора, Вы обязаны защищать, освобождать от
ответственности и возмещать убытки Нам, нашим аффилированным лицам, лицензиарам, каждому из наших
сотрудников, должностных лиц, директоров, в отношении любых исков, ущерба, ответственности, затрат и
сборов (включая разумные затраты за юридические услуги), возникших в результате или в связи с
использованием Вами Программного обеспечения (включая любой Контент, предоставляемый по настоящему
Договору) или в связи с нарушением настоящего Договора и/или любых заявлений или гарантий,
включенных в настоящий Договор. Вы соглашаетесь с тем, что Мы не принимаем на себя обязательств по
возмещению Вам убытков в связи с Вашим использованием Программного обеспечения или Контента.

13. ПРОЧИЕ УСЛОВИЯ

13.1. Лицензия, предоставляемая по настоящему Договору, применяется исключительно к версии
Программного обеспечения, предоставляемой в соответствии с настоящим Договором, а также в отношении
любых изменений и/или обновлений, на получение которых Вы можете иметь право. Во избежание сомнений,
Мы не обязаны предоставлять Вам какую-либо поддержку, средства устранения ошибок, изменения и
обновления Программного обеспечения.

13.2. Вы согласны соблюдать все применимые законы и подзаконные акты, относящиеся к Программному
обеспечению.

13.3. При дальнейшем распространении Программного обеспечения или Модификаций в рамках Вашего
Приложения, Вы вправе предлагать поддержку, гарантии, гарантии возмещения убытков и иные
обязательства и/или права, соответствующие условиям настоящего Договора. Тем не менее, при принятии
таких обязательств Вы вправе действовать исключительно от собственного имени и под свою
ответственность, но не от нашего имени. Вы должны возмещать Нам убытки или, по нашему выбору,
защищать нас от любых исков, претензий или судебных процессов, возбужденных против Нас (i) в связи с
тем, что Вы приняли на себя такую поддержку, гарантии, гарантии возмещения убытков или
дополнительную ответственность; или (ii) в связи с использованием, воспроизведением или
распространением Вашего Приложения, кроме случаев когда такой иск основывается исключительно на
включении Программного обеспечения в такое Приложение.

13.4. Более того, Вы должны распространять Программное обеспечение исключительно в соответствии с
соглашением, которое включает все ограничения, предусмотренные настоящим Договором, и в той же
степени защищает Нас и Программное обеспечение, как это делает настоящий Договор.

13.5. Вы признаете, что настоящий Договор является полным и единственным выражением нашего
соглашения. Никакая устная или письменная информация, предоставленная Нами или предоставленная иным
образом от Нашего имени, не создает каких-либо гарантий или дополнительных соглашений и никоим
образом не расширяет сферу действия настоящего Договора, и Вы не вправе полагаться на любую такую
устную или письменную информацию.

13.6. Настоящий Договор не предоставляет никаких подразумеваемых лицензий или подразумеваемых прав,
и все иные права, кроме прямо предоставленных по настоящему Договору, сохраняются за Нами и нашими
лицензиарами. Кроме того, никакие лицензии и привилегии не предоставляются в отношении
комбинирования Программного обеспечения и/или Модификаций, в зависимости от ситуации, с любым иным
программным обеспечением или аппаратными средствами, которые не были предоставлены Нами Вам по
настоящему Договору. Ваши права по настоящему Договору применяются только в отношении Программного
обеспечения, Модификаций и/или Приложений.

13.7. Если какие-либо положения настоящего Договора будут признаны недействительными, такие
положения считаются исключенными из настоящего Договора; остальные условия сохраняют полную силу и
действие.

13.8. Настоящий Договор регулируется законодательством соответствующей юрисдикции, в которой
лицензия исполняется. Если набор прав по суперимперативным нормам применимого законодательства в
соответствующей юрисдикции включает дополнительные права, не предусмотренные настоящей Лицензией,
такие дополнительные права считаются предоставленными по настоящей Лицензии в соответствии с
условиями настоящей Лицензии.

Редакция от 30.06.2014 г.


Дополнение А

Уведомление об авторском праве

Copyright © 2014 2GIS. Эксперт по городу. www.2gis.ru

Ниже предоставляется перечень компонентов с открытым кодом, как предусмотрено настоящим документом.
Данный перечень предоставляется для вашего удобства; пожалуйста, читайте далее, если желаете
ознакомиться с уведомлением(ями) об авторском праве и полным текстом лицензии, связанной с каждым
компонентом.

https://github.com/Leaflet/Leaflet/blob/master/LICENSE
https://github.com/linkedin/dustjs/blob/master/LICENSE
https://github.com/gulpjs/gulp/blob/master/LICENSE
https://github.com/mapbox/wellknown/blob/master/LICENSE


================================================
FILE: LICENSE_EN
================================================
THIS DOCUMENT IS A LEGAL AGREEMENT (the “Agreement”) BETWEEN DoubleGIS LLC ("We", "Us", "2GIS") AND
YOU ("You") IN RELATION TO API SOFTWARE (the "Software").

BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING THE SOFTWARE, YOU ACCEPT THE FOLLOWING TERMS
AND CONDITIONS. IF YOU DO NOT AGREE WITH ANY OF THE TERMS OR CONDITIONS OF THIS LICENSE AGREEMENT,
DO NOT PROCEED WITH THE DOWNLOADING, COPYING, INSTALLATION OR ANY OTHER USE OF THE SOFTWARE OR ANY
PORTION THEREOF AS YOU HAVE NO RIGHTS TO DO SO. THIS LICENSE AGREEMENT DESCRIBES YOUR RIGHTS AND
RESTRICTIONS WITH RESPECT TO THE SOFTWARE AND ITS COMPONENTS.

1.DEFINITIONS

"Application" means any software, application, or elements that You develop and operate using the
Software or Modifications in accordance with this Agreement.

"End User" means an end user of Your Application who acquires a license to such solely for their own
internal use and not for distribution, resale, user interface design or software development
purposes.

"Modification" means: a) any addition to or deletion from the contents of a file included in the
original Software or previous Modifications created by You, and/or b) any new file that leverages
any part of the original Software or previous Modifications.

"Source" form shall mean the preferred form for making modifications, including but not limited to
software source code, documentation source, and configuration files.

"Object" form shall mean any form resulting from mechanical transformation or translation of a
Source form, including but not limited to compiled object code, generated documentation, and
conversions to other media types.

"Hit Counter Script Code" means part of Source that is required for tracking, monitoring and
registration of End Users activity.

"API Software" ("Software") means DoubleGIS LLC application programming interface 2.0 version in the
form provided by DoubleGIS LLC to You, including any libraries, source code, documentation,
developer tools kit and other materials provided at https://github.com/2gis/maps-api-2.0 and
http://api.2gis.ru/ designated for modification, adaptation and any other software changes. Software
shall include any upgrades, updates, bug fixes or modified versions of the Software provided that We
are entitled to change the Software, as well as to modify or revoke this license agreement to use
the Software at Our sole discretion and at any time without giving You prior notice. The new version
of the Agreement shall enter into force on the date of its posting on the http://law.2gis.ru/,
unless otherwise provided in the new version of the agreement. In case of Your disagreement with the
use of a modified or updated version of the Software, the Section 7 of the Agreement shall apply.

"Logos" collectively means the DoubleGIS LLC trade names, trademarks, service marks, logos,
copyright notices, domain names and other Our distinctive brands.

"Databases" collectively means publicly accessible and displayed DoubleGIS LLC Databases of an
electronic map, which includes GIS data on geographical locations and settlements within an area
bounded by certain geographical coordinates.

"Content" means included, but is not limited to any piece of information stored in and/or retrieved
from the Databases and/or any other data or information DoubleGIS LLC chooses to include in its
Software. The use of any Content by You is limited to concurrent use with the Software.

2. LICENSE GRANT

2.1. Subject to your compliance with all of the terms and conditions of this Agreement, We grant a
perpetual for the duration of the applicable copyright, worldwide, non-exclusive, royalty-free and
not-sublicensable license (i) for You to use, copy, modify, merge the Software in source and object
forms to create Modifications and Applications; (ii) for You to publicly display, publicly perform
and at no-charge distribute the Software and/or Modifications in source and object forms to End
Users solely as integrated into the Applications; and (iii) for End Users to use the Software as
integrated into Your Applications in accordance with the terms of this Agreement; (iv) for You to be
enable Your Application to interact with the Databases and retrieve therefrom information necessary
to facilitate the use permitted under this Agreement; (v) for You to make limited intermediate
copies of the Content only as necessary to perform an activity permitted under this Agreement and to
modify (solely in order to rearrange or reorganize) the Content within Application; (vi)  for You to
disclose to the public the structure of the Software and the Source Code, provided that You properly
identify these by reference to Logo.

We reserve the right to modify, change, update and/or enhance the Software, the Databases, the
Source Code, and the Content at any time with or without notice to You Our sole and exclusive
discretion.

2.2. You may modify the Source Code solely for the purposes of designing, developing and testing
Your own Applications. However, You are permitted to use, copy, reproduce, distribute and
redistribute Your modified Source Code only if all of the following conditions are met: (a) You
include Our copyright notice (text is available in Exhibit A to this Agreement) with Your
Application, including every location in which any other copyright notice appears in such
Application; and (b) You do not otherwise use Our name, Logos or other of Our trademarks to market
Your Application, unless otherwise agree by Us in writing. Except to the above, You may not modify
remove or alter the Hit Counter Script Code contained in Software.

2.3. You will not owe Us any royalties for Your distribution of the Software in accordance with this
Agreement. You will not owe Us any fees for Your use or distribution of Applications in accordance
with this Agreement.

3.OWNERSHIP

3.1. This is a license agreement and not an agreement for sale. We reserve ownership of all
intellectual property rights inherent in or relating to the Software, which include, but are not
limited to, all copyright, patent rights, all rights in relation to registered and unregistered
trademarks (service marks), confidential information (including trade secrets and know-how) and all
rights other than those expressly granted by this Agreement.

3.2. We provide You with Source code so that You can create Modifications and Applications. While
You retain all rights to any original work authored by You as part of the Modifications, We continue
to own all copyright and other intellectual property rights in the Software, Source Code, Databases,
Content, Hit Counter script code.

3.3. You must not remove, obscure or interfere with any copyright, acknowledgment, attribution,
trademark, warning or disclaimer statement affixed to, incorporated in or otherwise applied in
connection with the Software.

4.FEEDBACK

4.1. DoubleGIS shall have a royalty-free, worldwide, perpetual license to use or incorporate into
the Software or Content any suggestions, ideas, enhancement requests, feedback, recommendations or
other information and derivatives thereof provided by You.

5.PROHIBITED USES

5.1. You may not redistribute the Software or Modifications other than by including the Software or
a portion thereof within Your Application. You may not change or remove the copyright notice from
any of the files included in the Software or Modifications. 5.2. The permission hereby is granted to
anyone to use this Software for any purpose,   excluding commercial applications, which is subject
to the restrictions of present Agreement. Software or Modifications shall be used only as integrated
into the Applications available for free public use.  Using of Software or Modifications for
projects intending payment or otherwise restricted access of the End Users to Databases or/and
Content are strictly prohibited. In case of commercial use is required, please contact us at
api@2gis.ru.

5.3. Open Source versions of the Software (“GPL Version”) may be licensed under the terms of the GNU
General Public License versions 3.0 (“GPL”) and not under this Agreement. If You, or another third
party, has, at any time, developed all (or any portions of) the Application(s) using a GPL Version,
You may not combine such development work with the Software and must license such Application(s) (or
any portions derived there from) under the terms of the GNU General Public License version 3, a copy
of which is located at http://www.gnu.org/copyleft/gpl.html.

6. RESTRICTIONS

6.1. Except as expressly authorized under this Agreement, Licensee shall not (i) use the Software,
the Databases, the Source Code, or the Content in any way not expressly permitted or granted under
this Agreement; (ii) copy the Content for purposes outside the scope of the license granted herein;
(iii) use the Content to create databases or any other compilations of Content, without Our prior
written consent; (iv)You shall not distribute, publish, facilitate, enable or allow access or
linking to the Content or Database from any location or source other than Your Application; (v) use
the Content to create an application that offers or promotes services that may be competitive with,
damaging to, disparaging of or otherwise detrimental to the Our service; (vi) crawl, spider, index
or in any way store information obtained from the Content (except for the limited license granted
herein), or propagate any virus, worms, Trojan horses, or other programming routine intended to
damage any system or data,  send or store infringing or unlawful material using the Software; (vii)
provide Content or Databases to any third parties in a manner contrary to the terms of use
applicable to users of the our web site; (viii) commercialize (i.e., sell, rent, or lease), copy,
store or cache the Content or Databases, other than for the purposes allowed by this Agreement.

6.2. Limits on Sublicensing. Except as set forth in this section, all license rights (under any
applicable intellectual property right) granted herein are not sublicenseable, transferable or
assignable. Subject to the terms and conditions below, You may sublicense Your right to display the
Content and the Logos, as provided in this Agreement, to End Users solely to enable End Users to
display Content and the Logos on their computer screens and/or websites through Your Application.

7.TERMINATION

7.1. This Agreement and Your right to use the Software and Modifications will terminate immediately
if You fail to comply with any of the terms and conditions of this Agreement. Upon termination, You
agree to immediately cease using and destroy the Software or Modifications, including all
accompanying documents.

8.DISCLAIMER OF WARRANTIES

8.1. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, WE DISCLAIM ALL WARRANTIES AND CONDITIONS,
EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND TITLE AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE. WE DO
NOT GUARANTEE THAT THE OPERATION OF THE SOFTWARE OR THE CODE IT PRODUCES WILL BE UNINTERRUPTED OR
ERROR-FREE, AND YOU ACKNOWLEDGE THAT IT IS NOT TECHNICALLY PRACTICABLE FOR US TO DO SO.

9.LIMITATION OF LIABILITIES

9.1. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT SHALL WE BE LIABLE UNDER ANY
LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING,
WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION OR ANY OTHER PECUNIARY LOSSES) ARISING OUT OF THE USE OF OR INABILITY TO USE THE
SOFTWARE OR THE CODE IT PRODUCES OR ANY OTHER SUBJECT MATTER RELATING TO THIS AGREEMENT, EVEN IF WE
HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

10.FREE SOFTWARE

10.1. Notwithstanding the foregoing, We acknowledges that certain components of the Software may be
covered by so-called "open source" software licenses ("Open Source Components"). We will prepare an
overview of the relevant free software and provide You with the complete corresponding source code,
including any modification We have made to that code if so. The overview shall be included in
Exhibit A, together with a copy of the license terms governing the relevant free software.

10.2. To the extent required by the licenses covering Open Source Components, the terms of such
licenses will apply in lieu of the terms of this Agreement, and We hereby represent that only Open
Source Components with licenses that intend to grant permissions no less broad than the license
granted in this Agreement are included in the Software. To the extent which the licenses applicable
to an Open Source Component prohibit any of the restrictions in this Agreement with respect to such
Open Source Component, such restrictions will not apply regarding to these Components.

11. INTELLECTUAL PROPERTY

11.1. The Software contain Our trademarks, logos, patents, trade secrets and/or copyrighted
materials. You shall not disclose or make available such trade secrets and/or know-how in any form
to any third party nor remove any trademark notices, copyright notices, or licensing terms from the
Software or any components therein. Title and intellectual property rights in and to Our trademarks
and Our copyrighted material which appears in content displayed by or accessed through the Software
belongs to Us.

11.2. Subject to the terms and conditions in, and during the term of, this Agreement, We grant you a
limited, nonexclusive, revocable, sublicensable license to display the trade names, trademarks,
service marks, logos, copyright notices, domain names and other Logos in accordance with this
Agreement and solely for attributing the source of the Software and for the purpose of promoting
and/or advertising that You use the Software and in your resulting Application.

11.3. At no time during or after the term of this Agreement shall you challenge or assist others to
challenge the Logos or, nor shall you attempt to register any Logos or brand identifiers (including
domain names) that are confusingly similar in any way to any of the Logos.

12.PARTIES INDEMNITY OBLIGATIONS

12.1 Subject to this Agreement, You shall defend, indemnify and hold Us, our affiliates, and
licensors, and each of Our respective employees, officers, directors, harmless from and against any
claims, damages, liabilities, costs and fees (including reasonable attorneys' fees) arising out of
or related to Your use of the Software (including all Content provided therein) or for any breach of
this Agreement and/or any of the representations and warranties made herein. You agrees that We
shall have no indemnity obligations for any use You make of the Software or the Content.

13.MISCELANEOUS

13.1. The license granted herein applies only to the version of the Software available in connection
with the terms of this Agreement, and to any updates and/or upgrades to which you may be entitled.
For the avoidance of doubt, We are not obligated to provide You with any support, bug fixes,
upgrades, or updates and/or upgrades to the Software.

13.2. You agree that you will comply with all applicable laws and regulations with respect to the
Software.

13.3. While redistributing the Software or Modifications thereof as part of Your Application, You
may choose to offer acceptance of support, warranty, indemnity, or other liability obligations
and/or rights consistent with this Agreement. However, in accepting such obligations, You may act
only on Your own behalf and on Your sole responsibility, not on our behalf. You shall indemnify Us,
or at Our option, defend Us against any claim, suit or proceeding brought against Us (i) arising by
reason of Your accepting any such support, warranty, indemnity or additional liability; or (ii)
arising out of the use, reproduction or distribution of Your Application, except to the extent such
claim is solely based on the inclusion of the Software therein.

13.4. Further, You agree only to distribute the Software pursuant agreement that includes all the
limitations and restrictions of this Agreement and is as protective of Us and Software as is this
Agreement.

13.5. You acknowledge that this Agreement is complete and is the exclusive representation of our
agreement. No oral or written information given by Us, or otherwise on Our behalf shall create a
warranty or collateral contract, or in any way increase the scope of this Agreement in any way, and
You may not rely on any such oral or written information.

13.6. There are no implied licenses or other implied rights granted under this Agreement, and all
rights, save for those expressly granted hereunder, shall remain with Us and our licensors. In
addition, no licenses or immunities are granted to the combination of the Software and/or
Modifications, as applicable, with any other software or hardware not delivered by Us to You under
this Agreement. Your rights under this Agreement apply only to Software, Modifications, and/or
Applications.

13.7. If any provision in this Agreement shall be determined to be invalid, such provision shall be
deemed omitted; the remainder of this Agreement shall continue in full force and effect.

13.8. This Agreement will be governed by the law s of the relevant jurisdiction in which the license
terms are sought to be enforced. If the suite of rights granted under super imperative rules of
applicable law in the relevant jurisdiction includes additional rights not granted under this
License, these additional rights are granted in this License in order to meet the terms of this
License.

Date: 30.06.2014 Exhibit A Copyright notice Copyright © 2014 2GIS. The City Expert. www.2gis.ru

The following is a listing of the open source components detailed in this document. This list is
provided for your convenience; please read further if you wish to review the copyright notice(s) and
the full text of the license associated with each component.
https://github.com/Leaflet/Leaflet/blob/master/LICENSE
https://github.com/linkedin/dustjs/blob/master/LICENSE
https://github.com/gulpjs/gulp/blob/master/LICENSE
https://github.com/mapbox/wellknown/blob/master/LICENSE


================================================
FILE: README.md
================================================
# API карт 2GIS [![npm][npm-badge]][npm-link]

[npm-badge]: https://img.shields.io/npm/v/2gis-maps.svg
[npm-link]: https://www.npmjs.com/package/2gis-maps

При помощи API карт вы сможете:
* создавать интерактивные карты на веб-странице;
* показывать на карте различные объекты (маркеры, балуны, геометрические фигуры);
* производить поиск на карте: определять координаты геообъектов по их названиям и названия по координатам.

Чтобы начать использовать API карт нужно получить ключ, для этого напишите на почту api@2gis.com, далее перейдите в раздел [Быстрый старт](https://docs.2gis.com/ru/maps/others/rasterjs/).

Если вы решили внести свой вклад в развитие продукта, ознакомьтесь с [инструкцией для контрибьюторов](https://github.com/2gis/maps-api-2.0/blob/master/CONTRIBUTING.md).

Также мы открыты для общения и готовы ответить на ваши вопросы, чтобы связаться с нами перейдите в раздел [Обратная связь](https://help.2gis.ru/feedback/).

Дополнительная информация:
* текущая версия API карт — 2.0;
* работает с использованием библиотеки [Leaflet](http://leafletjs.com);
* правовая информация доступна [на сайте 2ГИС](http://law.2gis.ru/api-rules/#kart2).


================================================
FILE: app/config.js
================================================
/**
 * Build config
 */
var fs = require('fs');
var _ = require('lodash');
var basePath = __dirname + '/..'; // Set root application path

var config = {
    mainAppConfig: basePath + '/config.main.json',
    localAppConfig: basePath + '/config.local.json',

    packages: require(basePath + '/gulp/deps/packs.js'),

    skins: ['dark', 'light'],

    source: {
        deps: require(basePath + '/gulp/deps/deps.js'),
        path: basePath + '/src/'
    },

    testSource: {
        deps: require(basePath + '/gulp/deps/deps.js'),
        path: basePath + '/gulp/tmp/testJS/src/'
    },

    leaflet: {
        deps: require(basePath + '/node_modules/leaflet/build/deps.js').deps,
        path: basePath + '/node_modules/leaflet/src/'
    },

    tmpl: {
        dir: 'templates',
        pattern: '*.dust',
        ext: '.dust',
        varPostfix: '_TMPL'
    },

    doc: {
        menu: './src/menu.json',
        input: './src/doc/',
        output: './dist/doc'
    },

    copyright: fs.readFileSync('./src/copyright.js'),

    coreModules: ['DGCore', 'DGCustomization', 'DGAjax']
};

function getMainConfig() {
    return require(config.mainAppConfig);
}

function getLocalConfig() {
    try {
        return require(config.localAppConfig);
    } catch (e) {
        return {};
    }
}

function getAppConfig() {
    return _.assign({}, getMainConfig(), getLocalConfig());
}

config.mainConfig = getMainConfig();
config.localConfig = getLocalConfig();
config.appConfig = getAppConfig();

module.exports = config;


================================================
FILE: app/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <title>API карт 2ГИС</title>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <script src="__BASE_URL__/loader.js"></script>

    <style>
        html,body { height: 100%; margin: 0; padding: 0; }
        #map { width: 100%; height: 100%; }
        .leaflet-touch .leaflet-bottom .dg-attribution { margin-top: 70px; }
        .leaflet-touch .leaflet-bottom .dg-zoom {margin: 40px 10px 40px 0; }
    </style>
</head>
<body>

<div id="map"></div>

<script>
    DG.then(function () {
        // change control position on touch devices
        var options = {
            center: [54.980156831455, 82.897440725094],
            zoom: 13,
            geoclicker: true,
            worldCopyJump: true,
            zoomControl: false,
            fullscreenControl: false,
            key: DG.config.key || 'Your API access key',
        };
        var query = parseQuery();
        var map = window.map = DG.map('map', getMapOptions(query, options));

        var controlOptions = DG.Browser.mobile ? {position: 'bottomright'} : {};
        DG.control.zoom(controlOptions).addTo(map);
        DG.control.traffic(controlOptions).addTo(map);
        DG.control.location(controlOptions).addTo(map);
        DG.control.ruler(controlOptions).addTo(map);
        if (DG.screenfull.isAvailable()) {
            DG.control.fullscreen(controlOptions).addTo(map);
        }
        var balloonHTML = '<a href="http://www.2gis.ru/" target="_blank">\n\
        <img src="__BASE_URL__/img/2gis-logo.png" alt="2GIS" title="2GIS" width="154" height="66" style="border: none"></a>\n\
        <p>Компания «ДубльГИС»</p>Тел.: (383) 363-05-55<br />Адрес: г. Новосибирск, Карла Маркса площадь, 7<br />\n\
        (МФК «Сан Сити»), 13 этаж';

        var marker = DG.marker([54.980156831455, 82.897440725094]).addTo(map).bindPopup(balloonHTML);

        if (query.lng === undefined && query.lat === undefined) {
            // only open popup when no coordinates specified because it moves map to popup
            marker.openPopup();
        }

        map.on('moveend', function() {
            if (!history.replaceState) {
                return; // ie <= 9
            }

            var center = map.getCenter();
            history.replaceState({}, document.title,
                '?lng=' + center.lng.toFixed(5) +
                '&lat=' + center.lat.toFixed(5) +
                '&zoom=' + map.getZoom()
            );
        });
    });

    function parseQuery() {
        var res = {};
        location.search.slice(1).split('&')
            .map(function(str) {
                return str.split('=')
            })
            .forEach(function(couple) {
                res[couple[0]] = couple[1];
            });
        return res;
    }

    function getMapOptions(query, options) {
        if (query.lng !== undefined && query.lat !== undefined) {
            options.center = [parseFloat(query.lat), parseFloat(query.lng)];
        }
        if (query.zoom !== undefined) {
            options.zoom = parseInt(query.zoom, 10);
        }
        return options;
    }
</script>
</body>
</html>


================================================
FILE: app/index.js
================================================
//Web app of 2GIS Maps API 2.0
var express = require('express');
var cors = require('cors');
var config = require('./config.js');
var _ = require('lodash');
var fs = require('fs');

// Init application
var app = express();
app.disable('x-powered-by');
app.use(cors());

// Serve loader
var loader = fs.readFileSync('./dist/loader.js', {encoding: 'utf8'});
app.get('/loader.js', function(req, res) {
    var localConfig = _.cloneDeep(config.localConfig);
    var protocol = config.appConfig.protocol;

    localConfig.protocol = protocol;

    res.set('Content-Type', 'application/javascript; charset=utf-8');

    var result = loader
        .replace(/__LOCAL_CONFIG__/g, JSON.stringify(localConfig))
        .replace(/__BASE_URL__/g, protocol + config.appConfig.baseUrl)
        .replace(/__QUERY__/g, JSON.stringify(req.query));

    // Send loader with injected params
    res.send(result);
});

// Load index file and inject base URL
var indexFile = fs.readFileSync('./dist/index.html', {encoding: 'utf8'});
indexFile = indexFile.replace(/__BASE_URL__/g, config.appConfig.baseUrl);

// Serve index file
function serveIndexFile(req, res) {
    res.send(indexFile);
}
app.get('/', serveIndexFile);
app.get('/index.html', serveIndexFile);
app.get('/healthcheck', function(req, res) {
    res.sendStatus(200);
});

function getParams(req) {
    var pkg = req.query.pkg;
    var skin = req.query.skin;
    var ie8 = req.query.ie8 === 'true';

    if (Object.keys(config.packages).indexOf(pkg) === -1) {
        pkg = 'full';
    }

    if (config.skins.indexOf(skin) === -1) {
        skin = config.appConfig.defaultSkin;
    }

    return {
        pkg: pkg,
        skin: skin,
        ie8: ie8
    }
}

function loadDir(dirPath) {
    var files = {};

    fs.readdirSync(dirPath).forEach(function(fileName) {
        files[fileName] = fs.readFileSync(dirPath + '/' + fileName);
    });

    return files;
}

// Load and serve JS files
var jsFiles = loadDir('./dist/js');
app.get('/js', function(req, res) {
    var params = getParams(req);
    var fileName = 'script.' + params.pkg + '.js';

    res.set('Content-Type', 'application/javascript; charset=utf-8');
    res.set('Cache-Control', 'public, max-age=84000');

    res.send(jsFiles[fileName]);
});

// Load and serve CSS files
var cssFiles = loadDir('./dist/css');
app.get('/css', function(req, res) {
    var params = getParams(req);

    var fileName = 'styles.' +
        params.pkg + '.' +
        params.skin + '.' +
        (params.ie8 ? 'ie8' + '.' : '') +
        'css';

    res.set('Content-Type', 'text/css');
    res.set('Cache-Control', 'public, max-age=84000');

    res.send(cssFiles[fileName]);
});

// Serve everything else
app.use(express.static(__dirname + '/../dist'));

// Start server
var host = config.appConfig.host;
var port = config.appConfig.port;

app.listen(port, host, function() {
    console.log('Maps API 2.0 server listening on ' + (host ? host + ':' : '') + port);
});


================================================
FILE: app/loader.js
================================================
(function() {
    'use strict';

    var isJSRequested = false;
    var rejects = [];
    var version = 'v4.0.12';
    var baseURL = '__BASE_URL__';
    var query = __QUERY__;
    var isLazy = query.lazy === 'true';
    var qs = getQueryString();

    function getQueryString() {
        var params = {
            skin: query.skin,
            pkg: query.pkg,
            version: version
        };

        if (/MSIE\x20(\d+\.\d+);/.test(navigator.userAgent) && parseInt(RegExp.$1, 10) < 9) {
            params.ie8 = true;
        }

        var qsComponents = [];

        for (var key in params) {
            var value = params[key];

            if (value) {
                qsComponents.push(key + '=' + value);
            }
        }

        if (!qsComponents.length) {
            return '';
        }

        return '?' + qsComponents.join('&');
    }

    function requestJS() {
        isJSRequested = true;

        var script = document.createElement('script');
        script.setAttribute('type', 'text/javascript');
        script.setAttribute('src', baseURL + '/js/' + qs);

        script.onerror = function(evt) {
            runRejects(evt);
        };

        document.getElementsByTagName('head')[0].appendChild(script);
    }

    // Returns a promise that resolves once the DOM is ready. Based on
    // https://github.com/addyosmani/jquery.parts/blob/master/jquery.documentReady.js
    function ensureDOMReady() {
        return new Promise(function(resolve, reject) {
            var isResolved = false;

            function resolveOnce() {
                // Clean up all listeners we added
                if (document.addEventListener) {
                    document.removeEventListener('DOMContentLoaded', resolveOnce, false);
                    window.removeEventListener('load', resolveOnce, false);
                } else {
                    document.detachEvent('onreadystatechange', resolveOnce);
                    window.detachEvent('onload', resolveOnce);
                }

                if (isResolved) {
                    return;
                }

                isResolved = true;
                resolve();
            }

            // Scroll check hack for IE8
            function doScrollCheck() {
                if (isResolved) {
                    return;
                }

                try {
                    document.documentElement.doScroll('left');
                } catch (e) {
                    setTimeout(doScrollCheck, 50);
                    return;
                }

                resolveOnce();
            }

            // If the DOM is already ready, load JS immediately
            if (document.readyState !== 'loading') {
                return resolveOnce();
            }

            // Adding event listeners. We also listen to window load event as a
            // 'better late than never' fallback.
            if (document.addEventListener) {
                document.addEventListener('DOMContentLoaded', resolveOnce, false);
                window.addEventListener('load', resolveOnce, false);
            } else if (document.attachEvent) { // IE8
                document.attachEvent('onreadystatechange', resolveOnce);
                window.attachEvent('onload', resolveOnce);

                // Scroll check hack for IE8
                var isTopLevel = false;
                try {
                    isTopLevel = window.frameElement == null;
                } catch (e) {}
                if (document.documentElement.doScroll && isTopLevel) {
                    doScrollCheck();
                }
            }
        });
    }

    function loadStylesheet() {
        var url = baseURL + '/css/' + qs;
        var style = document.createElement('style');
        style.type = 'text/css';

        return new Promise(function(resolve, reject) {
            DG.ajax(url, {
                type: 'get',

                dataType: 'html',

                success: function(data) {
                    var head = document.getElementsByTagName('head')[0];

                    // Replace urls in CSS in case local config was changed
                    // after build. originalBaseUrl contains URL value at the
                    // moment application was built. baseUrl contains current
                    // value.
                    var originalBaseUrl = '__ORIGINAL_BASE_URL__';

                    // Replace if they don't match
                    if (baseURL !== originalBaseUrl) {
                        data = data.replace(
                            new RegExp(originalBaseUrl, 'g'),
                            baseURL
                        );
                    }

                    if (style.styleSheet) {
                        head.appendChild(style);
                        style.styleSheet.cssText = data;
                    } else {
                        style.appendChild(document.createTextNode(data));
                        head.appendChild(style);
                    }

                    resolve();
                },

                error: function() {
                    reject();
                }
            });
        });
    }

    function loadProjectList() {
        var url = DG.config.protocol +
            DG.config.webApiServer + '/' +
            DG.config.webApiVersion + '/region/list';

        return new Promise(function(resolve) {
            DG.ajax(url, {
                type: DG.ajax.corsSupport ? 'get' : 'jsonp',

                data: {
                    format: DG.ajax.corsSupport ? 'json' : 'jsonp',
                    key: DG.config.webApiKey,
                    fields: DG.config.regionListFields
                },

                timeout: DG.config.loadProjectListTimeout,

                success: function(data) {
                    var result = data.result;

                    if (result && result.items && result.items.length) {
                        DG.projectsList = result.items;
                    }

                    resolve();
                },

                error: function(err) {
                    resolve();
                }
            });
        });
    }

    function extendConfig() {
        DG.extend(DG.config, __LOCAL_CONFIG__);

        if (DG.customConfig) {
            DG.extend(DG.config, DG.customConfig);
        }
    }

    function prepareForInit() {
        return Promise.all([
            loadStylesheet(),
            loadProjectList(),
            ensureDOMReady()
        ]);
    }

    function setReady() {
        DG.ready = true;
    }

    function runRejects() {
        for (var i = 0, l = rejects.length; i < l; i++) {
            if (typeof rejects[i] === 'function') {
                rejects[i]();
            }
        }
    }

    window.DG = window.DG || {};
    window.DG.ready = false;

    window.__dgApi__ = {
        callbacks: [
            [extendConfig, undefined],
            [prepareForInit, undefined],
            [setReady, undefined]
        ],
        version: version
    };

    var loaderDgThen = window.DG.then = function(resolve, reject) {
        if (DG.then !== loaderDgThen) {
            return DG.then(resolve, reject);
        }

        window.__dgApi__.callbacks.push([resolve, reject]);

        if (isLazy && !isJSRequested) {
            requestJS();
        }

        if (reject) {
            rejects.push(reject);
        }

        return this;
    };

    if (!isLazy) {
        requestJS();
    }
})();


================================================
FILE: assets/cluster_realworld.js
================================================
//An extract of address points from the LINZ bulk extract: http://www.linz.govt.nz/survey-titles/landonline-data/landonline-bde
//Should be this data set: http://data.linz.govt.nz/#/layer/779-nz-street-address-electoral/
var addressPoints = [
[54.9210922667, 82.8209316333, "2"],
[54.9210819833, 82.8213903167, "3"],
[54.9210881833, 82.8215004833, "3A"],
[54.9211946833, 82.8213655333, "1"],
[54.9209458667, 82.8214051333, "5"],
[54.9208292333, 82.8214374833, "7"],
[54.9325816, 82.8238798667, "537"],
[54.9315855167, 82.8279767, "454"],
[54.9096336833, 82.8223743833, "176"],
[54.90970685, 82.8221815833, "178"],
[54.9102146667, 82.8211562833, "190"],
[54.9088037167, 82.8242227, "156"],
[54.9112330167, 82.8193425667, "210"],
[54.9116368667, 82.8193005167, "212"],
[54.90812645, 82.8255449333, "146"],
[54.9080231333, 82.8286383167, "125"],
[54.9089538667, 82.8222222333, "174"],
[54.9080905833, 82.8275400667, "129"],
[54.908811, 82.8227592833, "172"],
[54.90832975, 82.8276898167, "131"],
[54.9089395333, 82.8281710333, "133"],
[54.9093421, 82.8274883167, "135"],
[54.9084820833, 82.82601925, "137"],
[54.90881015, 82.82622865, "139"],
[54.9090947667, 82.8263585667, "141"],
[54.9092962333, 82.8244872333, "147"],
[54.9091016667, 82.8249140167, "145"],
[54.9088785167, 82.8253611667, "143"],
[54.90825965, 82.82530115, "148"],
[54.90995685, 82.8238554333, "153"],
[54.90975435, 82.8238417833, "151"],
[54.90950755, 82.8237912, "149"],
[54.9092772667, 82.8231980833, "170"],
[54.9082753833, 82.80672975, "4"],
[54.9078434833, 82.811822, "56"],
[54.9083775667, 82.8090812333, "30B"],
[54.9084588, 82.8058838167, "174"],
[54.9088788333, 82.8062702833, "175"],
[54.9091632833, 82.80514875, "182A"],
[54.9094891167, 82.80384695, "202"],
[54.9156715667, 82.8034881667, "277"],
[54.9109189333, 82.8024631, "220"],
[54.9108164333, 82.8039622, "219"],
[54.9125773667, 82.8026079667, "238"],
[54.9125799333, 82.8032824, "241A"],
[54.9125869, 82.8037423833, "241C"],
[54.9140266833, 82.8025706, "256"],
[54.90932, 82.8051094333, "182B"],
[54.9098799667, 82.8040444167, "197"],
[54.9094298833, 82.80561245, "189"],
[54.9172409333, 82.8035291167, "287"],
[54.9232166667, 82.82452865, "2028"],
[54.9225024333, 82.8249944667, "2022"],
[54.92334135, 82.8244748667, "2030"],
[54.9229725333, 82.8246809333, "2026"],
[54.9224034667, 82.82507345, "2020"],
[54.9227806, 82.8248285833, "2024"],
[54.9178801, 82.8181871667, "6"],
[54.91811315, 82.8180543667, "4"],
[54.9181739833, 82.81851995, "1"],
[54.91797515, 82.8186312, "3"],
[54.9181787, 82.8176995, "2A"],
[54.9183385333, 82.81812895, "2"],
[54.9293053167, 82.8105357833, "31"],
[54.9309444333, 82.81208735, "16"],
[54.9306726667, 82.8115020833, "19"],
[54.9300903, 82.8120791, "26"],
[54.9289416167, 82.8113778333, "33"],
[54.9274969167, 82.8113355167, "53"],
[54.9199192667, 82.8173622833, "5A"],
[54.9200392833, 82.8174100167, "3"],
[54.9196328, 82.8167642, "18"],
[54.91752585, 82.8155467667, "22C"],
[54.91766615, 82.8153714167, "22B"],
[54.9179022667, 82.8151616833, "22A"],
[54.9191980333, 82.81664245, "20A"],
[54.91799325, 82.81565925, "20C"],
[54.9187486333, 82.8165228667, "20B"],
[54.91964875, 82.8172874167, "7"],
[54.91925545, 82.8171617, "11"],
[54.9190491667, 82.8170928333, "13"],
[54.9194515667, 82.8172147167, "9"],
[54.91981045, 82.81733245, "5B"],
[54.91876595, 82.8172445167, "15B"],
[54.9185999167, 82.8172441, "17A"],
[54.91816745, 82.81725905, "21B"],
[54.9182157167, 82.8164626333, "24"],
[54.9180109667, 82.8173984167, "23A"],
[54.9179918, 82.817159, "23B"],
[54.9188473167, 82.8170330333, "15"],
[54.9186481333, 82.8169800667, "17"],
[54.9184132, 82.8169327333, "19"],
[54.9202288333, 82.8174746333, "1"],
[54.918193, 82.8169955667, "21"],
[54.9178000833, 82.81733275, "25"],
[54.9176839, 82.8168488333, "26"],
[54.9198172, 82.8204960667, "5"],
[54.919986, 82.82049635, "3"],
[54.9197666, 82.8200825, "4"],
[54.9193835833, 82.8191669667, "10"],
[54.9193426333, 82.8198626667, "11"],
[54.9192171667, 82.8191711, "12"],
[54.9192621333, 82.8196364167, "13"],
[54.9195289667, 82.8193943167, "8"],
[54.91946, 82.8201499167, "9"],
[54.9196037833, 82.819674, "6"],
[54.9194712, 82.8204032, "7A"],
[54.9196381, 82.8203709333, "7"],
[54.9200137667, 82.8201364333, "2"],
[54.9191725167, 82.8193772833, "14"],
[54.9214417333, 82.8256822167, "4"],
[54.9210291, 82.8259429667, "8"],
[54.9212328333, 82.8258132, "6"],
[54.9216819833, 82.8253209, "3"],
[54.9334697167, 82.8038651667, "326"],
[54.9322603667, 82.8028621167, "317"],
[54.9322013667, 82.8046802667, "1/341"],
[54.9320576167, 82.8165535833, "435"],
[54.9319540333, 82.80506915, "2/341"],
[54.9316975667, 82.8053442333, "3/341"],
[54.9328229833, 82.8062598, "346"],
[54.93161565, 82.8074915, "355"],
[54.93219305, 82.80629425, "347"],
[54.9328549, 82.8080619667, "362"],
[54.9321289667, 82.8084019333, "367"],
[54.9322225167, 82.8120427667, "397"],
[54.9321649, 82.81119325, "393"],
[54.9321458833, 82.8131246333, "407"],
[54.9327043833, 82.81377405, "416"],
[54.9321267167, 82.8144058167, "417"],
[54.93212555, 82.8096521333, "373"],
[54.9331028667, 82.80928495, "366"],
[54.92866875, 82.82177625, "563"],
[54.9295602, 82.81924335, "582"],
[54.9304707833, 82.8182986167, "590"],
[54.93086, 82.8180687667, "592"],
[54.9328604833, 82.8172892167, "618"],
[54.9342575667, 82.8168357833, "638"],
[54.9239713, 82.8245693667, "504"],
[54.9365260167, 82.8170911, "673"],
[54.9233928833, 82.8249669167, "492"],
[54.9248650167, 82.8246300833, "509"],
[54.9191798333, 82.8265331667, "435"],
[54.9143243333, 82.8310940167, "368"],
[54.91459255, 82.8320046, "363"],
[54.91127515, 82.8356499167, "311"],
[54.9126359667, 82.8340855167, "333"],
[54.9096158333, 82.8375218167, "293"],
[54.9315868667, 82.8177722833, "604"],
[54.9160177667, 82.8299268333, "391"],
[54.9204715667, 82.8265481833, "456"],
[54.9206352, 82.8265670333, "458"],
[54.9208412667, 82.8265323333, "460"],
[54.9210184333, 82.82648325, "462"],
[54.9212643833, 82.8270422167, "465"],
[54.92119945, 82.8264274333, "464"],
[54.92136485, 82.8263145667, "466"],
[54.9215261, 82.82684075, "467"],
[54.9215301833, 82.8262078, "468"],
[54.9217701667, 82.8266360167, "1/471"],
[54.9218376833, 82.82686725, "2/471"],
[54.9217084667, 82.8260839667, "472"],
[54.9219782333, 82.8265028333, "475"],
[54.9218988833, 82.8259723, "476"],
[54.9223939333, 82.8262447, "479"],
[54.9223048667, 82.8256582833, "480"],
[54.9226657, 82.8261230833, "481"],
[54.9224199, 82.8255487833, "482"],
[54.9229134167, 82.8259527833, "485"],
[54.9226937833, 82.8253693167, "486"],
[54.9231509667, 82.8258170333, "487"],
[54.92295265, 82.8252571167, "488"],
[54.9233779, 82.8256743833, "489"],
[54.9232052667, 82.8251109333, "490"],
[54.9236200333, 82.82553395, "493"],
[54.92385775, 82.8253390833, "495"],
[54.9203220167, 82.82650925, "454"],
[54.9179795333, 82.8262826, "428"],
[54.91038215, 82.8365298167, "303"],
[54.9161746667, 82.8297239833, "393"],
[54.9083635333, 82.833955, "294"],
[54.92029495, 82.8214968167, "39"],
[54.9204754333, 82.8247793333, "12B"],
[54.9205440833, 82.82344905, "23"],
[54.9195974333, 82.8254019333, "2"],
[54.9210801, 82.8237748667, "20A"],
[54.9209057333, 82.82389775, "18"],
[54.9208016833, 82.8221582833, "32"],
[54.9209372667, 82.8236919, "20"],
[54.9210586833, 82.82351925, "22B"],
[54.92092905, 82.8234855333, "22"],
[54.9208587333, 82.8231887667, "24"],
[54.9210241167, 82.8230882, "24B"],
[54.9208547833, 82.8229410667, "26"],
[54.9209917, 82.8228447667, "26B"],
[54.92097645, 82.8227176167, "28B"],
[54.9208099167, 82.8226765167, "28"],
[54.9207666833, 82.8224338833, "30"],
[54.9209508833, 82.8222094167, "32B"],
[54.92076515, 82.8219195167, "34A"],
[54.9207399667, 82.8218131667, "34B"],
[54.9203075833, 82.8240482833, "19"],
[54.9205368167, 82.8237746667, "21"],
[54.9205025833, 82.8231658, "25A"],
[54.920465, 82.8229733667, "27"],
[54.92043535, 82.8227387, "29"],
[54.9204582, 82.8225319667, "31"],
[54.92024115, 82.8224347833, "31B"],
[54.9203792333, 82.8222631667, "33"],
[54.92034095, 82.8219843, "35"],
[54.9201566167, 82.8219446, "35B"],
[54.92030575, 82.8217594333, "37"],
[54.9202966833, 82.8233158167, "25"],
[54.9192714167, 82.8253842667, "1"],
[54.91969695, 82.82516645, "4"],
[54.9194904667, 82.82468815, "5"],
[54.9198524333, 82.8249096667, "6"],
[54.9200581833, 82.8247122, "8"],
[54.9193447, 82.8244639667, "5C"],
[54.9208238, 82.8241340167, "16"],
[54.9193183667, 82.82515695, "1A"],
[54.91940575, 82.8249383333, "3"],
[54.9211855167, 82.8242545333, "18A"],
[54.9207094833, 82.82430275, "14"],
[54.92027725, 82.82488135, "10A"],
[54.9202305833, 82.8245652667, "10"],
[54.9205049667, 82.8244201333, "12"],
[54.9196320333, 82.8255586, "22"],
[54.9209711, 82.8250444667, "8"],
[54.92120665, 82.8252942833, "5"],
[54.9210184, 82.8254290333, "7"],
[54.9213430333, 82.8252086167, "3"],
[54.9207887833, 82.8251555667, "10"],
[54.92060805, 82.8257042333, "13"],
[54.9208330333, 82.82553905, "9"],
[54.9216988833, 82.8249665667, "1"],
[54.9215665833, 82.8246573333, "2"],
[54.9213729, 82.8247789333, "4"],
[54.9211700667, 82.8249324333, "6"],
[54.9205967667, 82.8252867, "12"],
[54.9204008833, 82.8254234667, "14"],
[54.92043265, 82.82582195, "15"],
[54.9202037333, 82.8255415833, "16"],
[54.9200154333, 82.8256547667, "18"],
[54.9197443167, 82.8256164833, "20"],
[54.9202814333, 82.82590955, "17"],
[54.9202967667, 82.81462555, "98"],
[54.92204485, 82.81819735, "61B"],
[54.9224241, 82.8179326667, "61C"],
[54.9215043167, 82.8227943833, "24"],
[54.9219082, 82.8255408167, "8"],
[54.9216963, 82.8240856667, "14"],
[54.9213418333, 82.8188135667, "55"],
[54.9204966333, 82.8183406333, "54A"],
[54.9221799833, 82.81122085, "139"],
[54.9217387, 82.82431625, "12"],
[54.9218650167, 82.8149734167, "107"],
[54.9214083333, 82.8220152667, "30"],
[54.9213738333, 82.8217301, "32"],
[54.9221598167, 82.8247839333, "9"],
[54.9216356, 82.8235610667, "18"],
[54.9212188167, 82.8221387333, "30B"],
[54.9200466667, 82.8166111, "84A"],
[54.9216679333, 82.8238393333, "16"],
[54.9211582833, 82.82031685, "34"],
[54.9221918667, 82.8250378333, "7"],
[54.9187410167, 82.8067290167, "170C"],
[54.9206532, 82.8170745667, "81"],
[54.9212348667, 82.8181024167, "67"],
[54.9213057667, 82.8185351167, "57"],
[54.9214571, 82.8145877333, "110"],
[54.92207085, 82.8136727167, "121"],
[54.92190125, 82.8123493, "130"],
[54.9207519667, 82.8102467333, "150"],
[54.9212159, 82.8096407, "159"],
[54.9208313833, 82.8067756, "172"],
[54.9214413333, 82.8222779833, "28"],
[54.9206921333, 82.8182549, "54"],
[54.92043975, 82.8181215, "56"],
[54.9218791, 82.8252452167, "10"],
[54.92029435, 82.8169818, "84"],
[54.9215885167, 82.82308725, "22"],
[54.9215897333, 82.8233113167, "20"],
[54.92167455, 82.8183345, "61A"],
[54.9217164667, 82.8179857333, "63"],
[54.92147385, 82.82253565, "26"],
[54.9206765333, 82.8160304333, "86"],
[54.9188941, 82.8069437, "170A"],
[54.9188068333, 82.8068104833, "170B"],
[54.9193742667, 82.8085580333, "170"],
[54.9214388167, 82.8200072, "45"],
[54.9209547167, 82.8157149167, "92"],
[54.92088565, 82.8164849333, "85"],
[54.92136235, 82.8159546667, "97"],
[54.9219607333, 82.8232987, "19"],
[54.9210501, 82.8179753833, "69"],
[54.9212466667, 82.8222175833, "28A"],
[54.9213836167, 82.82300555, "22A"],
[54.921339, 82.8227439167, "24A"],
[54.9208144333, 82.8173117167, "77"],
[54.9189363667, 82.8211582333, "25"],
[54.9196676167, 82.8209947333, "26B"],
[54.9194113, 82.8211991, "26"],
[54.91883205, 82.8209747, "27"],
[54.9186925833, 82.8207728833, "29"],
[54.9199931833, 82.8240802167, "2"],
[54.9191759333, 82.8208279333, "30"],
[54.91835395, 82.8196571667, "39"],
[54.9198807333, 82.8235938167, "6"],
[54.9194567833, 82.82349015, "7"],
[54.9200507833, 82.81933875, "58"],
[54.9197902167, 82.8182408, "59A"],
[54.91991635, 82.81797195, "59B"],
[54.9198223833, 82.8179361833, "59C"],
[54.9201049333, 82.8197347167, "60"],
[54.9199380333, 82.81836645, "61A"],
[54.92003775, 82.8182443833, "61B"],
[54.9200944167, 82.81803015, "61C"],
[54.9201259667, 82.8185610667, "63"],
[54.92026275, 82.8188001167, "65"],
[54.9188917833, 82.8203729333, "34"],
[54.9184921333, 82.8203832, "33"],
[54.9190387167, 82.8206181333, "32"],
[54.91968705, 82.8224253667, "16"],
[54.91981205, 82.823119, "10"],
[54.9193882833, 82.8229798333, "11"],
[54.9190901167, 82.8227829833, "13B"],
[54.9193593, 82.8227247833, "13"],
[54.91993935, 82.8226893333, "14B"],
[54.91842725, 82.8201474167, "35"],
[54.9187965833, 82.8200475333, "36"],
[54.9183878167, 82.8198735667, "37"],
[54.9188702167, 82.8196982333, "38B"],
[54.92027885, 82.8209890667, "82"],
[54.9199839667, 82.8190668, "56"],
[54.9187008333, 82.81973745, "38A"],
[54.9196820167, 82.82262455, "14"],
[54.9186528333, 82.8191018, "42"],
[54.9182912167, 82.81915535, "43"],
[54.91870525, 82.81945675, "40"],
[54.9195044333, 82.8214081833, "24"],
[54.91857075, 82.8205925167, "31"],
[54.9195656167, 82.8181396, "57"],
[54.9198411667, 82.8213911167, "24A"],
[54.9195851667, 82.8240869667, "3"],
[54.9192829167, 82.8239720167, "3A"],
[54.9193257, 82.8224725667, "15"],
[54.9197290167, 82.8224129833, "16A"],
[54.9196499333, 82.8221262667, "18"],
[54.9196755333, 82.8243193333, "1"],
[54.9192091667, 82.82166805, "21"],
[54.91957585, 82.82166585, "22"],
[54.9199106833, 82.8238436, "4"],
[54.91953715, 82.82372785, "5A"],
[54.9193377833, 82.82378105, "5"],
[54.9189702833, 82.8184597333, "46"],
[54.9185876167, 82.81821495, "47A"],
[54.9185706333, 82.8178869167, "47B"],
[54.9191945667, 82.81845965, "48"],
[54.9188482167, 82.8176680833, "49"],
[54.9194043667, 82.81852395, "50"],
[54.9196233333, 82.8186248333, "52"],
[54.91920055, 82.8179787167, "53"],
[54.9198255, 82.8188011167, "54"],
[54.9205994333, 82.8207248667, "81"],
[54.9193045333, 82.8222075667, "17"],
[54.9205621167, 82.8204520167, "79"],
[54.9180799333, 82.8194407, "41A"],
[54.9208301833, 82.8206735833, "81A"],
[54.9202558, 82.8206809333, "80"],
[54.91941275, 82.81804965, "55"],
[54.9190239, 82.8179808833, "51"],
[54.9187854, 82.8180712167, "47"],
[54.9187476667, 82.8186516333, "44"],
[54.9182977, 82.81889655, "45"],
[54.91831675, 82.8194069833, "41"],
[54.9192735167, 82.8219502167, "19"],
[54.9196219167, 82.82189825, "20"],
[54.91962665, 82.8216432667, "22A"],
[54.9192782833, 82.8209942, "28"],
[54.9208129833, 82.8209176833, "83A"],
[54.9206351167, 82.8209705667, "83"],
[54.9203109333, 82.8212402667, "84"],
[54.91909575, 82.82139795, "23"],
[54.9197787167, 82.8228814, "12"],
[54.9195628333, 82.81791605, "57A"],
[54.9198373833, 82.8233606833, "8"],
[54.9194342167, 82.82322975, "9"]
];

================================================
FILE: assets/heat_realworld.js
================================================
//An extract of address points from the LINZ bulk extract: http://www.linz.govt.nz/survey-titles/landonline-data/landonline-bde
//Should be this data set: http://data.linz.govt.nz/#/layer/779-nz-street-address-electoral/
var addressPoints1 = [
[54.8839, 82.3745188667, "571"],
[54.8869090667, 82.3657417333, "486"],
[54.8894207167, 82.4015351167, "807"],
[54.8927369333, 82.4087452333, "899"],
[54.90585105, 82.4453463833, "1273"],
[54.9064188833, 82.4441556833, "1258"],
[54.90584715, 82.4463564333, "1279"],
[54.9033391333, 82.4244005667, "1078"],
[54.9061991333, 82.4492620333, "1309"],
[54.9058955167, 82.4445613167, "1261"],
[54.88888045, 82.39146475, "734"],
[54.8950811333, 82.4107982, "928"],
[54.88909235, 82.3922956333, "740"],
[54.8889259667, 82.3938591667, "759"],
[54.8876576333, 82.3859563833, "687"],
[54.89027155, 82.3973178833, "778"],
[54.8864473667, 82.3806136833, "631"],
[54.9000262833, 82.4183242167, "1012"],
[54.90036495, 82.4189457, "1024"],
[54.9000976833, 82.4197312167, "1027"],
[54.90239975, 82.42371165, "1067"],
[54.9043379667, 82.42430325, "1080"],
[54.9026441, 82.4231055167, "1068"],
[54.8883536333, 82.3888573833, "718"],
[54.9029948833, 82.4237386167, "1070"],
[54.89824135, 82.4150421667, "982"],
[54.8976067833, 82.41510265, "983"],
[54.9023491333, 82.4225495, "1066"],
[54.8856157167, 82.3775632833, "608"],
[54.8963032667, 82.4132068, "951"],
[54.8922813667, 82.4073402333, "1/898"],
[54.88933345, 82.3956084333, "769"],
[54.8936148833, 82.4090577, "906"],
[54.8939398, 82.4094444833, "914"],
[54.8857355333, 82.3722297667, "542"],
[54.8931092167, 82.4083014, "898"],
[54.9008253167, 82.4198128, "1030"],
[54.9045052333, 82.4260735, "1100"],
[54.9053927167, 82.42822265, "1130"],
[54.90507935, 82.4313065, "1147"],
[54.9055749667, 82.4319092167, "1154"],
[54.9039034833, 82.4274736667, "1/1105"],
[54.9037633, 82.4261181833, "1093"],
[54.9038755, 82.42871045, "3/1105"],
[54.90369555, 82.4285285, "2/1105"],
[54.9056626, 82.4341078833, "1170"],
[54.9018736833, 82.438852, "1/1213"],
[54.9057596167, 82.4356650167, "1180"],
[54.9053502, 82.4361049333, "1185"],
[54.9053379167, 82.4366986167, "1195"],
[54.9058892333, 82.4381450333, "1204"],
[54.9060264167, 82.4400763167, "1220"],
[54.9056766833, 82.4412592, "1233"],
[54.9057312167, 82.4418380333, "1235"],
[54.9061575833, 82.4421068667, "1242"],
[54.9063946167, 82.4438004667, "1256"],
[54.8996027667, 82.43995055, "4/1215"],
[54.9006449667, 82.4395556833, "3/1215"],
[54.9009138167, 82.4394061333, "2/1215"],
[54.9034547, 82.4396315, "1219"],
[54.9055243, 82.4396033, "1221"],
[54.89952325, 82.4406619167, "5/1215"],
[54.90561525, 82.4404853167, "1225"],
[54.9045602333, 82.4477690333, "1285"],
[54.9040051667, 82.4388491833, "1213"],
[54.90588145, 82.4440349167, "1257"],
[54.90595915, 82.4389286833, "1212"],
[54.9059939667, 82.4398068833, "1218"],
[54.8868631833, 82.37991055, "630"],
[54.8878744833, 82.382179, "650"],
[54.8880764, 82.3839845667, "670"],
[54.8850457333, 82.3759821, "594"],
[54.88446045, 82.3762872667, "587"],
[54.8880782667, 82.38423415, "1/670"],
[54.8863533833, 82.3690698667, "515"],
[54.8861783167, 82.3710009833, "530"],
[54.885424, 82.3716677833, "541"],
[54.88524065, 82.3722141167, "547"],
[54.9022371333, 82.47991035, "10"],
[54.9020014833, 82.4799581667, "1"],
[54.9020824, 82.4802630167, "2"],
[54.9018589833, 82.4804760833, "3"],
[54.9018211333, 82.4806769667, "4"],
[54.9021543667, 82.4805538833, "5"],
[54.9022658, 82.4807579333, "6"],
[54.9024517833, 82.4806480667, "7"],
[54.9024251167, 82.48041985, "8"],
[54.9023317833, 82.4802119667, "9"],
[54.9321212167, 82.4555088, "39"],
[54.8956185167, 82.4719458667, "4"],
[54.8954566, 82.4728120333, "20"],
[54.8957231833, 82.4727906, "22A"],
[54.8956085833, 82.4726702, "22"],
[54.8956460167, 82.4718485167, "2"],
[54.8953487167, 82.47202915, "5"],
[54.8800121167, 82.4865467167, "9"],
[54.8803487833, 82.48595255, "3"],
[54.8802064167, 82.4861004, "5"],
[54.8800705167, 82.4862671167, "7"],
[54.8798887333, 82.4863712333, "7A"],
[54.8801676667, 82.4866722667, "10"],
[54.88029245, 82.4868499667, "8"],
[54.8803302167, 82.4865822167, "6"],
[54.88038715, 82.4864004167, "4"],
[54.8805029333, 82.4862314167, "2"],
[54.9127148667, 82.4710607833, "51"],
[54.9118609667, 82.4668648, "20"],
[54.9122010667, 82.47078695, "49A"],
[54.91191245, 82.4682913833, "29"],
[54.9112774333, 82.4668027333, "17A"],
[54.91244995, 82.4700709833, "41"],
[54.9149636, 82.4772568333, "98"],
[54.9128421833, 82.4702103167, "42"],
[54.91130515, 82.4650217667, "2"],
[54.9140405333, 82.4754503833, "85"],
[54.91155815, 82.4670938833, "21"],
[54.9144416167, 82.4754564, "86"],
[54.91149715, 82.4668828667, "19"],
[54.9155068167, 82.4784839167, "116"],
[54.9135311667, 82.4736794833, "69"],
[54.9146717667, 82.4773664833, "103"],
[54.913582667, 82.4724437333, "62"],
[54.9117463, 82.4676612167, "23"],
[54.9136108833, 82.47263915, "64"],
[54.9118005167, 82.46788515, "25"],
[54.9142630167, 82.4748833333, "80"],
[54.9118481833, 82.4680930167, "27"],
[54.91519165, 82.47727755, "100"],
[54.9121701, 82.4679073167, "28"],
[54.9152358167, 82.4780924833, "112"],
[54.9122425667, 82.4681859167, "30"],
[54.9150027167, 82.47843285, "107"],
[54.91196865, 82.4684916833, "31"],
[54.9132330333, 82.4726685333, "61"],
[54.9123722, 82.4685087667, "32"],
[54.915824667, 82.4790262, "113"],
[54.9120319833, 82.46868985, "33"],
[54.9151328167, 82.4788729, "111"],
[54.9124617167, 82.4687799833, "34"],
[54.9150617167, 82.4786454167, "109"],
[54.9120926, 82.4688931667, "35"],
[54.9132881333, 82.47285965, "63"],
[54.9119984333, 82.4691844, "37A"],
[54.9120311, 82.4673706667, "24"],
[54.91214925, 82.46909885, "37"],
[54.91408025, 82.4759690833, "91B"],
[54.9125366, 82.4691343, "38"],
[54.9134794833, 82.4739836167, "71A"],
[54.9122081167, 82.4674649333, "26A"],
[54.9140814333, 82.4736708667, "72A"],
[54.9120801, 82.4675947333, "26"],
[54.9113324167, 82.46512405, "4"],
[54.91185795, 82.4686138167, "31A"],
[54.9144403167, 82.4767387667, "101"],
[54.9125054167, 82.46896025, "36A"],
[54.9151334833, 82.4778022667, "106"],
[54.9126167833, 82.4688409667, "36B"],
[54.9111576, 82.4663765167, "13A"],
[54.9112960833, 82.4662379, "13"],
[54.9116252167, 82.46602135, "14"],
[54.9113666167, 82.4664507833, "15"],
[54.9117068333, 82.466336, "16"],
[54.9114338333, 82.4666576, "17"],
[54.9119338667, 82.4665694167, "18A"],
[54.9117808333, 82.4665752, "18"],
[54.9110205, 82.4652438667, "3"],
[54.9110742833, 82.4654501167, "5"],
[54.9111370833, 82.4656566833, "7"],
[54.9111865833, 82.4658542667, "9"],
[54.9112390333, 82.46602075, "11"],
[54.9118135167, 82.46543705, "6A"],
[54.9118572167, 82.46556135, "6B"],
[54.91145615, 82.4655286, "6"],
[54.9115389167, 82.4657957167, "8"],
[54.9127748333, 82.4699760667, "40"],
[54.9125127167, 82.4703133, "43"],
[54.9129274, 82.4704172833, "44"],
[54.9125759833, 82.4705303667, "45"],
[54.9129758667, 82.4706118, "46"],
[54.9126359667, 82.4707644, "47"],
[54.91226225, 82.47106665, "49"],
[54.9130937833, 82.4709588833, "50"],
[54.9131644667, 82.4711523, "52"],
[54.9132299667, 82.4713462167, "60"],
[54.9127690833, 82.4712279667, "53"],
[54.9133607167, 82.4730695833, "65"],
[54.91367805, 82.4728816667, "66"],
[54.9134211, 82.4732760667, "67"],
[54.9137477833, 82.4731176, "68"],
[54.9138932333, 82.4736511667, "70"],
[54.9135950667, 82.4738879833, "71"],
[54.9139430167, 82.4737982333, "72"],
[54.9136486, 82.4740868667, "73"],
[54.91400415, 82.4740125833, "74"],
[54.9140350333, 82.4741693833, "76"],
[54.91432385, 82.475081, "82"],
[54.9139975333, 82.47523055, "83"],
[54.9143889667, 82.47526065, "84"],
[54.9137640333, 82.47575135, "87"],
[54.91449875, 82.4756521167, "88"],
[54.9141123, 82.4756848833, "89"],
[54.9145492167, 82.4758458667, "90"],
[54.9141779667, 82.4758650667, "91"],
[54.9146104833, 82.4760345, "92"],
[54.9142320333, 82.4760478833, "93"],
[54.9146642167, 82.47621125, "94"],
[54.9142896667, 82.4762277667, "95"],
[54.9147136833, 82.4764402833, "96"],
[54.9143434167, 82.47639805, "97"],
[54.9143937167, 82.4765685, "99"],
[54.91501315, 82.4774403667, "102"],
[54.9154860667, 82.4774428167, "104"],
[54.9149432667, 82.4782801, "105"],
[54.9152651667, 82.47833035, "114"],
[54.9299333167, 82.55909085, "128"],
[54.9286782833, 82.5545978, "181"],
[54.9300747333, 82.5497311333, "3/193"],
[54.9276611167, 82.5543011333, "192"],
[54.9305557833, 82.5594630333, "129"],
[54.9280362, 82.5517895, "2/193"],
[54.9284764, 82.5616764333, "103"],
[54.93143935, 82.55390345, "165"],
[54.9288132, 82.5647016167, "61"],
[54.9275235, 82.5619954833, "94"],
[54.93081245, 82.5577222333, "149"],
[54.9300416667, 82.5566331333, "161"],
[54.92921255, 82.5684947, "16"],
[54.9304111667, 82.5673126333, "35"],
[54.9291729667, 82.5653647333, "55"],
[54.9289266333, 82.5656691333, "56"],
[54.92751825, 82.5531413167, "1/193"],
[54.9323321667, 82.5512635167, "1/165"],
[54.9045377667, 82.4827770167, "3"],
[54.9051343333, 82.4829339167, "10"],
[54.9045625, 82.4832139167, "4"],
[54.9052854167, 82.4828661667, "12"],
[54.9045012833, 82.4825234, "3A"],
[54.9054383, 82.4831963, "14"],
[54.9048575167, 82.4826078167, "7"],
[54.9050790667, 82.4825558167, "9A"],
[54.90496205, 82.4830191667, "8"],
[54.9050431833, 82.4823803833, "9B"],
[54.9047063167, 82.4826914667, "5"],
[54.9051649333, 82.4825182667, "11"],
[54.9047697333, 82.4831092667, "6"],
[54.9044120833, 82.4828407333, "1"],
[54.8987653333, 82.4845873667, "12"],
[54.89849935, 82.4843253333, "8"],
[54.8989808833, 82.4835699333, "13"],
[54.8982670333, 82.4839818167, "5"],
[54.89792805, 82.4841291833, "1"],
[54.8990696333, 82.48395625, "18"],
[54.8983429167, 82.4837488833, "7A"],
[54.8986908667, 82.4846387167, "10"],
[54.8985086333, 82.48330895, "9A"],
[54.8980756833, 82.4840675333, "3"],
[54.8984572667, 82.4838707, "7"],
[54.8988333833, 82.48411825, "16"],
[54.89797735, 82.4845139167, "2"],
[54.8988639833, 82.4832473, "9B"],
[54.8985740667, 82.4844548333, "8A"],
[54.8983953667, 82.4832022167, "9"],
[54.898132, 82.48448765, "4"],
[54.8983169333, 82.48441905, "6"],
[54.898835, 82.4848386, "12A"],
[54.8982524667, 82.4837739667, "5A"],
[54.7992683667, 82.4068494, "44D"],
[54.7973138333, 82.40680895, "37"],
[54.79798795, 82.4063265667, "41"],
[54.7983426667, 82.4060350833, "38"],
[54.7981863, 82.40728095, "45"],
[54.7985252667, 82.4070533167, "46"],
[54.7991710833, 82.4079073667, "44A"],
[54.7994488333, 82.4084595333, "44B"],
[54.7998703833, 82.4089765833, "44C"],
[54.7969343667, 82.4040572333, "15"],
[54.7991115833, 82.406026, "44E"],
[54.9108972667, 82.4737860333, "1"],
[54.9109227833, 82.4740157167, "3"],
[54.9110122167, 82.47419315, "5"],
[54.91133475, 82.4740478833, "6"],
[54.91125305, 82.4738936667, "4"],
[54.9111422333, 82.4736767667, "2"],
[54.9110952167, 82.47448295, "7"],
[54.9112131667, 82.4741245667, "8"],
[54.8804519333, 82.4809153167, "16A"],
[54.8808188333, 82.4804471833, "8"],
[54.8805619667, 82.4804252833, "10"],
[54.8810451833, 82.4809865167, "11"],
[54.8806955167, 82.4806394, "12"],
[54.8808969, 82.48108405, "13"],
[54.8806416, 82.4807763833, "14"],
[54.8807567, 82.48110125, "15"],
[54.8806444167, 82.4809707333, "16"],
[54.8805414833, 82.4812062167, "17"],
[54.8812994167, 82.4798864833, "1"],
[54.8810411333, 82.4798769333, "2"],
[54.8812669, 82.4801150167, "3"],
[54.8810092333, 82.4800721333, "4"],
[54.8811867333, 82.48041535, "5"],
[54.8809235, 82.4802776833, "6"],
[54.8811437833, 82.4806999667, "7"],
[54.8811760167, 82.4808741333, "9"],
[54.8778504833, 82.5246844167, "102"],
[54.8819230667, 82.52038225, "37"],
[54.8838481333, 82.5190955, "15"],
[54.8825636667, 82.5211268, "42"],
[54.8789988, 82.528298167, "79"],
[54.8729074667, 82.5286693667, "167"],
[54.8760724333, 82.52502585, "127"],
[54.8745184833, 82.5278637167, "148"],
[54.8744641, 82.5268869667, "145"],
[54.8971449, 82.3967563, "82"],
[54.8943781833, 82.3977300667, "44"],
[54.9004613, 82.47640765, "13"],
[54.9004093667, 82.4762205333, "11"],
[54.9002790833, 82.4769703167, "16"],
[54.9003597167, 82.4772565, "20"],
[54.90090275, 82.4763007167, "15"],
[54.90094715, 82.4764403167, "17"],
[54.9006751333, 82.4771785333, "27"],
[54.90107225, 82.4768541333, "25"],
[54.9001119667, 82.4749271333, "1"],
[54.9006160667, 82.4769211667, "23"],
[54.9002628, 82.4757354, "3"],
[54.9005473333, 82.4767056, "19"],
[54.9002167333, 82.4750815167, "2"],
[54.8998862167, 82.4772123833, "18"],
[54.9003037333, 82.47596475, "9"],
[54.9000952167, 82.4752010833, "2A"],
[54.9006044167, 82.475943, "9A"],
[54.9085414, 82.47102025, "1"],
[54.90831215, 82.4705452333, "4"],
[54.9085338333, 82.4706769667, "2"],
[54.90815565, 82.470603, "5"],
[54.9082244667, 82.4708460167, "6"],
[54.9083062, 82.4711227667, "7"],
[54.9084509833, 82.47045035, "3"],
[54.8911392333, 82.4583220667, "8"],
[54.891127, 82.4585561667, "10"],
[54.8912095833, 82.4581187333, "7"],
[54.8910674833, 82.4575599333, "2"],
[54.8913220333, 82.4574411833, "1"],
[54.89159775, 82.4573200333, "1A"],
[54.8910451833, 82.4580652333, "6"],
[54.8913072667, 82.4576702667, "3"],
[54.8913322, 82.4579054333, "5"],
[54.8910210167, 82.45784865, "4"],
[54.8853014, 82.4629564833, "3"],
[54.88554135, 82.4629736, "2"],
[54.88541785, 82.46296925, "1"],
[54.9193531833, 82.54385725, "354"],
[54.9188882667, 82.5420886333, "355"],
[54.9192738333, 82.5435102833, "356"],
[54.9192985333, 82.5429392833, "358"],
[54.9193181167, 82.54233135, "360"],
[54.9192005, 82.5403558833, "130"],
[54.9186817333, 82.5404104667, "109"],
[54.9199342167, 82.5412764833, "260"],
[54.9193768333, 82.5412782167, "223"],
[54.91831485, 82.5400403333, "103"],
[54.91961875, 82.5408546833, "200"],
[54.9176805, 82.5413459167, "105"],
[54.9190955, 82.5408870167, "171"],
[54.9182861833, 82.5408937167, "107"],
[54.9195153, 82.5433797, "352"],
[54.92030865, 82.54192075, "264"],
[54.920463, 82.5417725, "262"],
[54.9197269667, 82.5432480167, "350"],
[54.9197592167, 82.5415707667, "266"],
[54.9195913167, 82.54231935, "348"],
[54.9183186167, 82.5393124667, "2"],
[54.9187989667, 82.53988695, "70"],
[54.9185694, 82.5418133, "353"],
[54.8994012, 82.3657659333, "821"],
[54.89971895, 82.3645648833, "835"],
[54.9139332167, 82.4090271667, "332"],
[54.8988464667, 82.3659825667, "828"],
[54.9022981, 82.38067085, "685"],
[54.9065350333, 82.4018221167, "434"],
[54.90028885, 82.3798328667, "697"],
[54.9084945333, 82.4050759167, "410"],
[54.89922135, 82.3740981833, "747"],
[54.9232422167, 82.4145657333, "185"],
[54.9245097667, 82.41242555, "187"],
[54.9159503333, 82.40778185, "303"],
[54.9094665, 82.4069157667, "388"],
[54.9231998333, 82.4170489, "158"],
[54.9102601, 82.4072221667, "383"],
[54.9207001, 82.4065603167, "257"],
[54.9102264, 82.4082195, "372"],
[54.928280667, 82.4087488, "233"],
[54.9021599833, 82.3911428167, "598"],
[54.9229502667, 82.4127942667, "197"],
[54.90296435, 82.3924815167, "583"],
[54.9255960833, 82.4136194333, "2/187"],
[54.9245176, 82.4278129833, "59"],
[54.9249067167, 82.4263146667, "75"],
[54.92534045, 82.4130770333, "1/187"],
[54.9077678, 82.4038107833, "424"],
[54.9244162333, 82.4258990667, "76"],
[54.9237273333, 82.4194401833, "138"],
[54.9019339833, 82.3879181167, "625"],
[54.90920365, 82.4053418167, "397"],
[54.9057407667, 82.39478875, "540"],
[54.9243174333, 82.4220341833, "112"],
[54.8992012333, 82.3666729333, "815"],
[54.9110874833, 82.4102195833, "360"],
[54.9027096, 82.3913196333, "591"],
[54.9011183833, 82.38410915, "655"],
[54.9234701333, 82.4155696333, "181"],
[54.9025482, 82.3926162167, "582"],
[54.92450575, 82.4246711167, "90"],
[54.9242924167, 82.4289432833, "47"],
[54.8986079833, 82.3685293333, "801"],
[54.9030857, 82.3932839, "577"],
[54.90235535, 82.3894401667, "613"],
[54.9008578833, 82.3826145667, "675"],
[54.90071405, 82.3818195, "681"],
[54.8820639667, 82.4856738333, "4"],
[54.8811382833, 82.4847224333, "17"],
[54.8820705, 82.4859065167, "2"],
[54.8822594167, 82.4854946333, "5"],
[54.88230695, 82.4860176667, "1"],
[54.8816572833, 82.4846057667, "14"],
[54.8822931167, 82.4857413833, "3"],
[54.8820614833, 82.4849636833, "10"],
[54.8814784167, 82.4853259333, "20"],
[54.8820341167, 82.4854254, "6"],
[54.8814562667, 82.4855579, "22"],
[54.8820407667, 82.4852060167, "8"],
[54.88139725, 82.4857370167, "24"],
[54.8819474, 82.4846312, "12"],
[54.8812179833, 82.4855291833, "23"],
[54.8811665833, 82.4849644, "19"],
[54.8822871333, 82.4850344167, "9"],
[54.8822664667, 82.4852611, "7"],
[54.8813914667, 82.4847524, "16"],
[54.8812347667, 82.4852638167, "21"],
[54.8814556, 82.48509055, "18"],
[54.8811484833, 82.4844946, "15"],
[54.8823244833, 82.4848154333, "11"],
[54.8823452833, 82.4845833667, "13"],
[54.9599893167, 82.5018972167, "82"],
[54.9618358833, 82.4874459667, "18"],
[54.9618619, 82.50776785, "90"],
[54.9616283333, 82.4929460167, "64"],
[54.9611726167, 82.4984393667, "80"],
[54.9607851, 82.5016190333, "86"],
[54.9608416167, 82.4971466, "78"],
[54.9614436333, 82.5080607667, "92"],
[54.9643050333, 82.4953529167, "2/84"],
[54.9610803, 82.4864609, "7"],
[54.9606146667, 82.4939399, "83"],
[54.9609926167, 82.4857235333, "3"],
[54.96113465, 82.4948554, "84"],
[54.9613254333, 82.5047791833, "88"],
[54.8593059833, 82.5330650333, "10"],
[54.8596072333, 82.533587, "19"],
[54.90423375, 82.4844148, "107B"],
[54.9020309333, 82.4769959167, "49A"],
[54.9029281167, 82.4805014167, "81A"],
[54.9016197667, 82.4756437833, "37"],
[54.90101005, 82.4735379833, "21"],
[54.9016823667, 82.4760847833, "39A"],
[54.90178185, 82.4761837333, "41"],
[54.9011922667, 82.4725514167, "8"],
[54.9015593833, 82.4738315333, "26"],
[54.9015446833, 82.473388, "18A"],
[54.9024291, 82.4783928, "57"],
[54.9010319, 82.4736316167, "23"],
[54.9039576333, 82.4835641667, "103"],
[54.9011953333, 82.4741573333, "29A"],
[54.9042121, 82.4828802833, "100"],
[54.9010152, 82.4741578667, "29B"],
[54.9019761833, 82.4752665167, "34"],
[54.90256225, 82.4788024667, "71"],
[54.9031558833, 82.4793385, "68"],
[54.9043412833, 82.48477025, "109A-109D"],
[54.9030168667, 82.4803624833, "81"],
[54.9054432333, 82.48740955, "114"],
[54.9032955667, 82.4821555167, "93B"],
[54.9052043, 82.4875160667, "118"],
[54.9040282167, 82.4838154167, "105"],
[54.90498365, 82.4875592167, "120"],
[54.90388715, 82.4833244, "101"],
[54.90156105, 82.47306285, "1/14-5/14"],
[54.9028688, 82.4798400167, "77"],
[54.908212, 82.4730746667, "16A"],
[54.9034353833, 82.48239905, "95A"],
[54.9018501333, 82.47294875, "16B"],
[54.9065120667, 82.4873521833, "114A"],
[54.9027523, 82.47799015, "58"],
[54.9029325833, 82.4801074833, "79"],
[54.9032525167, 82.4811784, "87"],
[54.9031822833, 82.4809204, "85"],
[54.9033394667, 82.4814522333, "89"],
[54.9011077167, 82.4738625833, "25"],
[54.9024641, 82.4756984333, "40"],
[54.9044449, 82.4836965167, "104"],
[54.9023471833, 82.47810245, "55"],
[54.9029669667, 82.4787094167, "62"],
[54.90442275, 82.4850982, "115"],
[54.9026089, 82.47587495, "44"],
[54.90264365, 82.4790681667, "73"],
[54.9035878333, 82.4823534, "95"],
[54.9024915, 82.4786270833, "67"],
[54.9031010167, 82.4812452667, "87A"],
[54.9030982, 82.47913305, "66"],
[54.9035099167, 82.4821307, "93A"],
[54.90079465, 82.4741973833, "33"],
[54.9040185667, 82.48229025, "96"],
[54.9023384167, 82.4765524833, "50"],
[54.9022154167, 82.4786401833, "59"],
[54.9018837333, 82.4765543333, "45"],
[54.9029163333, 82.4785064167, "60"],
[54.9022748167, 82.4763478167, "48"],
[54.9041422, 82.4826398833, "98"],
[54.9022017333, 82.4761212333, "46A"],
[54.9034542333, 82.4818904, "91"],
[54.9019505833, 82.4767386667, "47"],
[54.9018310833, 82.4763711167, "43"],
[54.9022245, 82.4761991, "46B"],
[54.9022058833, 82.4776710667, "51"],
[54.9011141167, 82.4738904667, "31"],
[54.90381365, 82.48307595, "99"],
[54.9013508667, 82.4731568833, "14"],
[54.9026744667, 82.4776618667, "54"],
[54.9013012667, 82.4729456, "12"],
[54.9016709167, 82.4758279833, "39"],
[54.9012509333, 82.4727291833, "10"],
[54.902262, 82.4778573167, "53"],
[54.9011626167, 82.4723885667, "6"],
[54.9015607167, 82.4753714333, "35"],
[54.9007910667, 82.47417145, "27"],
[54.9020738833, 82.47565455, "36"],
[54.9010502667, 82.4719555, "4"],
[54.9036689667, 82.4826166, "97"],
[54.90165275, 82.4742215833, "28"],
[54.9043576, 82.4834127, "102"],
[54.9014172833, 82.4734044167, "18"],
[54.90310965, 82.4806441333, "83"],
[54.90305305, 82.4810779, "85A"],
[54.9041825833, 82.4842419667, "107A"],
[54.9018864667, 82.4749266667, "32"],
[54.9018503333, 82.47696095, "49"],
[54.9030326167, 82.47892515, "64"],
[54.9017621333, 82.4733169667, "20"],
[54.89705485, 82.4732848667, "5"],
[54.8972060833, 82.4727957833, "1A"],
[54.8950392167, 82.47373745, "28B"],
[54.8965514333, 82.4726139833, "6"],
[54.8952181167, 82.4744414833, "33B"],
[54.8952637167, 82.47354965, "26A"],
[54.8951086667, 82.4742331167, "33A"],
[54.8966904333, 82.4729455, "11A"],
[54.8962754333, 82.4733100167, "17"],
[54.8968641333, 82.4728138667, "1/3-5/3"],
[54.8949580667, 82.4743396167, "35"],
[54.8973106167, 82.4729746, "1B"],
[54.8949376167, 82.47388345, "30"],
[54.89572315, 82.4732895, "18"],
[54.8958303167, 82.4731749333, "16"],
[54.8969656167, 82.4732634, "7"],
[54.896495, 82.4731159833, "13"],
[54.8968125667, 82.4731199333, "11B"],
[54.89640605, 82.4732035667, "15"],
[54.8952445667, 82.4736735667, "26"],
[54.8960091167, 82.47303035, "14"],
[54.896205, 82.47289145, "10"],
[54.8956152, 82.4738212833, "29"],
[54.8950829667, 82.4737896, "28A"],
[54.8955509167, 82.4734385333, "22"],
[54.8972144833, 82.4729756, "1C"],
[54.8970069167, 82.4727237833, "1D"],
[54.8964112667, 82.4727309333, "8"],
[54.89685155, 82.4723649167, "2"],
[54.8959909833, 82.4735371333, "19"],
[54.8968653333, 82.4732429833, "9"],
[54.8952936, 82.4740853667, "31"],
[54.8956491833, 82.47335855, "20"],
[54.8971588833, 82.4725988, "1"],
[54.95948505, 82.3813743167, "3/362"],
[54.9267924667, 82.3947664833, "790"],
[54.95374205, 82.3785110333, "417"],
[54.9270906333, 82.3962139333, "802"],
[54.95208085, 82.3790772833, "435"],
[54.9537863833, 82.37916715, "418"],
[54.9336977167, 82.3872475333, "660"],
[54.9370890667, 82.3861055333, "610"],
[54.9632177167, 82.37745245, "310"],
[54.9552044167, 82.3775981, "391"],
[54.95356905, 82.3785904167, "419"],
[54.9658669167, 82.3737947167, "273"],
[54.9591853, 82.37834395, "360"],
[54.95818485, 82.3776341167, "1/362"],
[54.9264044, 82.3933694833, "770"],
[54.94279195, 82.3830579333, "541"],
[54.9358610167, 82.3856405, "623"],
[54.92604605, 82.39188825, "762"],
[54.95893715, 82.3798225167, "2/362"],
[54.9257693333, 82.3904065167, "750"],
[54.9654268167, 82.3769618333, "308"],
[54.9323014833, 82.3868321333, "743"],
[54.93764955, 82.3850314, "599"],
[54.9095889, 82.4694829333, "13"],
[54.9099912333, 82.4694063167, "4"],
[54.9101332, 82.4693430167, "2"],
[54.90943375, 82.4691617333, "9"],
[54.90960705, 82.46916755, "7"],
[54.9100405, 82.4689760667, "1"],
[54.9095270167, 82.4693311, "11"],
[54.9098948167, 82.4690437, "3"],
[54.9097340167, 82.4696952667, "10"],
[54.9095571, 82.4697117833, "12"],
[54.90975285, 82.4691024667, "5"],
[54.9018515667, 82.47956045, "10"],
[54.9025733333, 82.4796073833, "1A"],
[54.90234615, 82.4792779, "4"],
[54.9027908167, 82.4795601333, "1"],
[54.9024103667, 82.47967745, "3"],
[54.90205615, 82.4794369167, "8"],
[54.89827985, 82.4664433333, "25"],
[54.8990345167, 82.4670508, "11"],
[54.8989251667, 82.4664513667, "17"],
[54.8990204833, 82.4665540333, "15"],
[54.8996123667, 82.4678836167, "10"],
[54.89873215, 82.4672828, "18"],
[54.89858465, 82.4666028667, "21"],
[54.8990743833, 82.4675788, "12A"],
[54.8984592, 82.4665057, "23"],
[54.89889965, 82.467451, "12"],
[54.9002081667, 82.46756315, "1"],
[54.9001357167, 82.4679316667, "4"],
[54.898277, 82.46726385, "24"],
[54.89978315, 82.46793515, "8"],
[54.8983929667, 82.4669553667, "26"],
[54.8991940667, 82.4672154167, "9"],
[54.8980936167, 82.4664998167, "27"],
[54.8995042, 82.4674747167, "7"],
[54.898334, 82.46731845, "22"],
[54.8999632833, 82.4679440333, "6"],
[54.89794665, 82.4665422333, "29"],
[54.8988821167, 82.4669019167, "13"],
[54.8980275167, 82.4668801333, "30"],
[54.89871525, 82.4676048667, "14"],
[54.8977558667, 82.4665362333, "31"],
[54.8986535, 82.4675602667, "16"],
[54.8979195833, 82.4667739667, "32"],
[54.89979585, 82.4675336833, "5"],
[54.8974943167, 82.46652485, "33"],
[54.8987147333, 82.46672835, "19"],
[54.8977257333, 82.4666500833, "34"],
[54.8985690333, 82.4671123833, "20"],
[54.9003081667, 82.46791995, "2"],
[54.8981989167, 82.4668991, "28"],
[54.8999918333, 82.4675733167, "3"],
[54.9085979, 82.47228295, "6"],
[54.9082979333, 82.4727952, "1"],
[54.9084415, 82.4723396833, "4"],
[54.9085185333, 82.4726990667, "3"],
[54.90870765, 82.4724272833, "8"],
[54.9082453167, 82.4725341667, "2"],
[54.9087162, 82.4725830333, "5"],
[54.8992527333, 82.4614825, "5A"],
[54.8974537333, 82.4597499, "30"],
[54.8990513167, 82.461357, "5"],
[54.89854655, 82.4618827833, "2"],
[54.8962418167, 82.4614646667, "69"],
[54.89729515, 82.4597868833, "32"],
[54.8986072, 82.4598125833, "18"],
[54.8990041, 82.4601224, "17"],
[54.8986801, 82.46007825, "16"],
[54.8976013667, 82.4596983333, "28"],
[54.8987992333, 82.4607934667, "10"],
[54.8961486, 82.4612296167, "65"],
[54.8987145333, 82.4602998667, "14"],
[54.8986250667, 82.4616027833, "6"],
[54.8985372, 82.4606703, "12A"],
[54.8990944833, 82.4618171167, "3A"],
[54.8987547833, 82.4605145833, "12"],
[54.8989327667, 82.46174375, "3"],
[54.89940475, 82.4614229833, "5B"],
[54.8981109833, 82.4595815167, "22"],
[54.8992761667, 82.4612548833, "7A"],
[54.89858635, 82.4617420167, "4"],
[54.89615355, 82.4610093667, "63"],
[54.8960633167, 82.4614357, "67"],
[54.8970480833, 82.4594701667, "47"],
[54.8964719167, 82.4610726, "46"],
[54.89942805, 82.4612639, "7B"],
[54.8969129333, 82.4595048833, "49"],
[54.8983810333, 82.4595983, "20"],
[54.8966503, 82.4601548, "40"],
[54.8965228167, 82.4605625667, "42"],
[54.8979410167, 82.4596252, "24"],
[54.89698365, 82.45986105, "36"],
[54.89909445, 82.46094265, "9"],
[54.8990747, 82.4611943333, "7"],
[54.8968194333, 82.4598978167, "38"],
[54.8990957833, 82.4607578667, "11"],
[54.8993121167, 82.4605309833, "13A"],
[54.8993347667, 82.4606526667, "11A"],
[54.8977427333, 82.4596749667, "26"],
[54.8964422833, 82.4608866833, "44"],
[54.897148, 82.4598171667, "34"],
[54.8964457667, 82.4614839667, "50"],
[54.8965226, 82.4613232333, "48"],
[54.89666225, 82.4616268167, "50A"],
[54.8967215667, 82.4614938667, "48A"],
[54.8961699833, 82.4606764833, "61"],
[54.8990274167, 82.4594845333, "21A"],
[54.8978044833, 82.4592938, "37"],
[54.89765145, 82.45932785, "39"],
[54.8972011167, 82.4594360833, "45"],
[54.89748945, 82.45936165, "41"],
[54.8973585333, 82.4594078333, "43"],
[54.8989135833, 82.4593674167, "23A"],
[54.8982502167, 82.4591910333, "31"],
[54.8980929167, 82.4592136833, "33"],
[54.8979576667, 82.4592540667, "35"],
[54.8987865, 82.459442, "23"],
[54.8983624667, 82.4591781333, "29"],
[54.89859365, 82.4592542667, "25"],
[54.8984648833, 82.4592043833, "27"],
[54.89599285, 82.4605853833, "61A"],
[54.8967193667, 82.4595488167, "51"],
[54.89895945, 82.45991735, "19"],
[54.8988903667, 82.4596039833, "21"],
[54.8991762833, 82.4598346833, "19A"],
[54.8990309833, 82.4603212, "15"],
[54.8992306667, 82.4600061667, "17A"],
[54.8990798333, 82.46053775, "13"],
[54.8960234, 82.46042255, "59A"],
[54.8961819167, 82.4595465333, "55A"],
[54.8965562167, 82.4596334167, "53"],
[54.8962467833, 82.4604475, "59"],
[54.8961687167, 82.459936, "57A"],
[54.8963601167, 82.4599881167, "57"],
[54.8964266, 82.4598209333, "55"],
[54.89876895, 82.4610164333, "8"],
[54.89888655, 82.46191985, "1"],
[54.8992657, 82.4618445667, "3B"],
[54.89942775, 82.46177925, "3C"],
[54.8994213333, 82.461939, "3D"],
[54.8877845667, 82.4769104167, "15A"],
[54.8884691333, 82.47652905, "9"],
[54.8876236833, 82.4762465333, "14"],
[54.8881092667, 82.4765359833, "11"],
[54.8870282333, 82.47689615, "21"],
[54.8878168667, 82.4761862, "12"],
[54.8869641167, 82.4766908333, "20"],
[54.88876965, 82.4761694167, "7"],
[54.8866340667, 82.4762948167, "20D"],
[54.8875209833, 82.4767726667, "17"],
[54.8878835333, 82.4766054, "13"],
[54.8870823167, 82.4763955, "18"],
[54.8885070833, 82.4758756667, "6"],
[54.8880108, 82.4760921833, "10"],
[54.8888735667, 82.4758855333, "5"],
[54.8879635, 82.4768245333, "13A"],
[54.8890102, 82.4753934667, "1"],
[54.887397, 82.4763382, "16"],
[54.8867165333, 82.4763817833, "20C"],
[54.8881819, 82.4760513167, "8"],
[54.886801, 82.4764408667, "20B"],
[54.8873439167, 82.4769787167, "19A"],
[54.88688675, 82.47651985, "20A"],
[54.8872187, 82.4769650667, "19"],
[54.8874603333, 82.4770461667, "19B"],
[54.8877107667, 82.4766732833, "15"],
[54.9028793667, 82.4694345, "9"],
[54.9027742, 82.4691508167, "5"],
[54.9027706333, 82.46934705, "7"],
[54.9030670833, 82.4689651833, "4"],
[54.903068, 82.4692231333, "6"],
[54.90282975, 82.4689251167, "2"],
[54.9030033, 82.4694327333, "8"],
[54.7979216167, 82.3709623333, "40"],
[54.7901529, 82.3755824, "144"],
[54.7907598333, 82.3744419, "134"],
[54.7937929667, 82.3664199167, "59C"],
[54.79439395, 82.3674624167, "59B"],
[54.7944289667, 82.3725634167, "82A"],
[54.7904513167, 82.3738425333, "131"],
[54.794607, 82.3745403833, "82B"],
[54.7921551167, 82.3768403, "132"],
[54.7926399833, 82.3722763, "102"],
[54.7967557, 82.3729791333, "60A"],
[54.7921326333, 82.37322975, "110"],
[54.8012874, 82.3703331, "14"],
[54.7948232167, 82.3716246, "74"],
[54.7979944667, 82.3703715167, "35"],
[54.7956465, 82.3714636167, "66"],
[54.7911951833, 82.3732412833, "123B"],
[54.7987651833, 82.3708161667, "32"],
[54.79171095, 82.3736367667, "112"],
[54.7976371833, 82.3704513833, "41"],
[54.7911877333, 82.3732945667, "123A"],
[54.7913029167, 82.37306835, "121"],
[54.7906186667, 82.3755869, "140"],
[54.7931244667, 82.3712613167, "93A"],
[54.7974290667, 82.3711039667, "42"],
[54.7936148167, 82.3719375667, "84"],
[54.8005517667, 82.3700387, "9"],
[54.7938986667, 82.3710440333, "77"],
[54.7965492333, 82.3713085167, "54"],
[54.8001176167, 82.3701064333, "13"],
[54.7930191667, 82.37129215, "93B"],
[54.7926151667, 82.37155955, "99A"],
[54.7950692833, 82.3686159167, "59A"],
[54.7969088, 82.37462925, "60B"],
[54.7951773167, 82.37087185, "75"],
[54.7921505, 82.3713529333, "99B"],
[54.7904565167, 82.3749809333, "138"],
[54.8006982167, 82.3700011, "7"],
[54.7991912, 82.3699700833, "29"],
[54.7967847667, 82.3705662167, "47"],
[54.792296, 82.3720602333, "99C"],
[54.7980087167, 82.36967245, "31"],
[54.7982152833, 82.3709274, "34"],
[54.9155702167, 82.4723301167, "4"],
[54.9159029, 82.4721897167, "8"],
[54.9157610833, 82.4726929667, "3"],
[54.9160956333, 82.4725375333, "7"],
[54.9153328, 82.4724436667, "2"],
[54.9164312667, 82.4723669167, "11"],
[54.9165995, 82.4722833833, "13"],
[54.9162671833, 82.4724523333, "9"],
[54.9162124833, 82.4720273, "12"],
[54.9160704833, 82.4720950333, "10"],
[54.9170187667, 82.4717177667, "22"],
[54.9164956667, 82.4718994167, "16"],
[54.9163615667, 82.4719599333, "14"],
[54.9155396833, 82.4728079667, "1"],
[54.9157325833, 82.4722579833, "6"],
[54.9159316, 82.47261835, "5"],
[54.8914888167, 82.4620999667, "21"],
[54.8837548, 82.4623328, "77B"],
[54.8930618833, 82.4622745, "11"],
[54.8852888667, 82.46116795, "76"],
[54.8913069667, 82.4621727167, "23"],
[54.8839160167, 82.4615298167, "75"],
[54.8883285167, 82.4618738833, "47"],
[54.8858521667, 82.46093185, "68B"],
[54.8853005333, 82.4610670333, "76A"],
[54.88383285, 82.4621270167, "75A"],
[54.8823235167, 82.4605504833, "110A"],
[54.8914899333, 82.46174725, "22"],
[54.8818567333, 82.4608746167, "116"],
[54.88353235, 82.4618320333, "77A"],
[54.8813482, 82.4613161333, "95"],
[54.8879809, 82.4618373667, "49"],
[54.88152115, 82.46131485, "93"],
[54.8885148667, 82.4618976167, "45"],
[54.8872325667, 82.4613256333, "54"],
[54.8877582, 82.4620199, "51A"],
[54.8837208833, 82.4615252, "77"],
[54.8879695167, 82.4611445833, "50A"],
[54.8933130333, 82.46192685, "6"],
[54.88794035, 82.46146015, "50"],
[54.8911399667, 82.4621445, "25"],
[54.8927127, 82.4625991167, "15"],
[54.8898722833, 82.4620120667, "37"],
[54.8817498333, 82.4605830833, "118A"],
[54.8856498167, 82.4611874667, "70"],
[54.8818152333, 82.4605837833, "118B"],
[54.8834546167, 82.4619323333, "1/79-3/79"],
[54.8817077833, 82.46087495, "120"],
[54.88566165, 82.4608763667, "70B"],
[54.8881064833, 82.4614714667, "48"],
[54.8883276833, 82.4614909, "46"],
[54.8900726, 82.4616307167, "34"],
[54.8824921167, 82.4614109333, "85"],
[54.8902574, 82.4620445833, "33"],
[54.8821857333, 82.4613799, "89"],
[54.8909901, 82.4620973667, "27"],
[54.8906249333, 82.4624066333, "31A"],
[54.8909031667, 82.4623998167, "27A"],
[54.8823715333, 82.4609577, "110"],
[54.8885618333, 82.4615104, "44"],
[54.8907907, 82.4624375833, "29A"],
[54.8911051167, 82.4615235333, "26A"],
[54.8912843667, 82.46171725, "24"],
[54.88775155, 82.4618187333, "51"],
[54.88202465, 82.4608939, "114"],
[54.8877833167, 82.4614137, "52"],
[54.8907810833, 82.462108, "29"],
[54.8910314667, 82.4617401833, "26"],
[54.882292, 82.4613977333, "87"],
[54.8906141333, 82.4621064667, "31"],
[54.8892757667, 82.4615758167, "38"],
[54.8904495, 82.4624898833, "33B"],
[54.8868235333, 82.461296, "58"],
[54.8904039167, 82.4622297, "33A"],
[54.8826623167, 82.4609461833, "106"],
[54.89295465, 82.4615430167, "14B"],
[54.8907016, 82.46165145, "28"],
[54.89291045, 82.4618812167, "14"],
[54.8854757, 82.461181, "74"],
[54.8930916667, 82.46189575, "12"],
[54.8856999, 82.4605845, "70A"],
[54.8928368667, 82.4622630833, "13"],
[54.8899615833, 82.4616178167, "36"],
[54.8925096667, 82.4618395167, "16A"],
[54.8927205667, 82.4618461, "16"],
[54.8925576333, 82.4622484333, "17"],
[54.8887964167, 82.4615352, "42"],
[54.8887897667, 82.4619157667, "43"],
[54.8813160833, 82.46082205, "124"],
[54.88148945, 82.46084125, "122"],
[54.8822301, 82.4605952667, "112B"],
[54.8821928667, 82.4609133167, "112A"],
[54.8825255, 82.4609447167, "108"],
[54.886356, 82.4607633833, "62A"],
[54.88384855, 82.46107535, "84"],
[54.8844810833, 82.46111955, "78"],
[54.8865957833, 82.4612863167, "60"],
[54.8870465333, 82.4613338333, "56"],
[54.8840136833, 82.4610932, "82"],
[54.8840612333, 82.4615617667, "73"],
[54.8858403667, 82.4612416667, "68A"],
[54.8863992833, 82.4612464333, "62"],
[54.88602145, 82.4612203, "66"],
[54.8862464, 82.4607918667, "64A"],
[54.8859472, 82.4606057333, "66A"],
[54.88617885, 82.4612264667, "64"],
[54.8841155833, 82.4606926667, "82A"],
[54.8842170667, 82.46156725, "71"],
[54.8843494167, 82.4615815167, "69"],
[54.8845482333, 82.4615789, "61"],
[54.8832313667, 82.4614822, "81"],
[54.8833854333, 82.46147585, "79"],
[54.8842273333, 82.4610982667, "80"],
[54.8842230833, 82.4607088333, "80A"],
[54.88898595, 82.4619261, "41"],
[54.8836924167, 82.4610583833, "86"],
[54.88897595, 82.4615556167, "40"],
[54.8835485833, 82.4610374, "88"],
[54.8812029, 82.4608328833, "126"],
[54.8834193333, 82.4610251833, "90"],
[54.8174314833, 82.3761889833, "28"],
[54.882173333, 82.3745060667, "41A"],
[54.8189801, 82.3767644333, "19"],
[54.81721685, 82.3746944667, "40A"],
[54.8184217833, 82.3785756333, "7"],
[54.81727655, 82.3739209, "41C"],
[54.8169354333, 82.3751527667, "40B"],
[54.8183142667, 82.3745782, "39"],
[54.8177220333, 82.3774063833, "18"],
[54.8181192333, 82.3734650333, "41B"],
[54.8182567, 82.37774445, "15"],
[54.8177787833, 82.3756114, "31"],
[54.8171698, 82.37896375, "14"],
[54.8179103833, 82.3762068167, "27"],
[54.81816045, 82.3773152167, "17"],
[54.8187562833, 82.3765890167, "21"],
[54.81804885, 82.3788571, "6"],
[54.8184971667, 82.3750758833, "49"],
[54.8173303, 82.3796556667, "12"],
[54.8177653667, 82.3776830167, "16"],
[54.81610655, 82.3744603333, "40C"],
[54.882659833, 82.3767630167, "24"],
[54.8857427167, 82.4668167833, "6"],
[54.8842291667, 82.46713325, "21"],
[54.88552105, 82.46728075, "7"],
[54.8822557833, 82.4671910833, "41A"],
[54.88573115, 82.4665300333, "6A"],
[54.8841256167, 82.4667261, "22"],
[54.8855689, 82.4668563667, "8"],
[54.8833609167, 82.4664140667, "30A"],
[54.8819612833, 82.4662849167, "42A"],
[54.8854916667, 82.4665621167, "8A"],
[54.88355305, 82.4666830167, "28"],
[54.8858997833, 82.46683345, "2"],
[54.88529365, 82.4675717333, "9A"],
[54.8853087167, 82.46724515, "9"],
[54.8858362167, 82.4668311, "4"],
[54.88501735, 82.4672261167, "13"],
[54.88173245, 82.4665125833, "44"],
[54.8819903833, 82.4669395333, "43"],
[54.8819599, 82.46652035, "42"],
[54.8821801667, 82.4669412, "41"],
[54.8820951, 82.4665340833, "40"],
[54.8822636667, 82.4665534167, "36"],
[54.8836934333, 82.4671131833, "27"],
[54.8817733333, 82.4669241, "45"],
[54.8811819833, 82.46709535, "49A"],
[54.8812991667, 82.4664858167, "48"],
[54.8815565333, 82.4668967167, "47"],
[54.8815367, 82.46651585, "46"],
[54.8837635333, 82.4667121, "26"],
[54.8811047333, 82.466856, "51"],
[54.8810985833, 82.4664679167, "50"],
[54.8813315833, 82.46687885, "49"],
[54.8838189667, 82.4665006, "26A"],
[54.8840672667, 82.46711675, "23"],
[54.8838811667, 82.4670993333, "25"],
[54.8839458833, 82.4667205667, "24"],
[54.8832529, 82.4673047167, "33A"],
[54.8835982, 82.4664604333, "28A"],
[54.8830642667, 82.4666342167, "32"],
[54.8835364167, 82.4675321, "29"],
[54.8834683333, 82.4670743667, "31"],
[54.883317, 82.4666640833, "30"],
[54.8851499333, 82.4667468, "12"],
[54.8851338167, 82.46723935, "11"],
[54.8828958667, 82.4666283167, "34"],
[54.88325825, 82.46707095, "33"],
[54.8853570333, 82.4667731167, "10"],
[54.88494775, 82.4672146833, "15"],
[54.8854012333, 82.466548, "10A"],
[54.88298215, 82.4670794667, "35"],
[54.9137448167, 82.4769976167, "9"],
[54.9139995, 82.4769421167, "1"],
[54.9137195833, 82.4762766333, "5"],
[54.9136874333, 82.4768144167, "8"],
[54.9138555833, 82.4762229167, "4"],
[54.9139553833, 82.4765034, "3"],
[54.9139429833, 82.4767303, "2"],
[54.91357485, 82.4763857833, "6"],
[54.91363055, 82.47658545, "7"],
[54.9070534333, 82.4673664667, "26"],
[54.9051596, 82.4668419167, "13"],
[54.9107910167, 82.4652498167, "70"],
[54.9049454167, 82.4681745833, "8"],
[54.9086697833, 82.466192, "46A"],
[54.9049889333, 82.4680154333, "8A"],
[54.90506145, 82.4674941833, "7"],
[54.9106372333, 82.4652995167, "68"],
[54.9083611333, 82.4663507667, "42"],
[54.9062177333, 82.4681393167, "16B"],
[54.91076535, 82.46463305, "71"],
[54.90610465, 82.46785555, "16A"],
[54.9054751167, 82.4677389667, "12"],
[54.9058089833, 82.4680032167, "14A"],
[54.9054853667, 82.4672854833, "17"],
[54.90856345, 82.4665805333, "44"],
[54.9088263, 82.4661217333, "48"],
[54.9101238833, 82.4655415667, "62"],
[54.908529, 82.4662483167, "46"],
[54.9056721833, 82.46797, "12A"],
[54.9057461833, 82.4675941167, "14"],
[54.90600145, 82.4670439167, "23"],
[54.9076178833, 82.4673104167, "34A"],
[54.90463895, 82.46807945, "3"],
[54.9049602667, 82.4669330833, "9"],
[54.90673685, 82.4671040833, "22"],
[54.907098, 82.4676191667, "32"],
[54.9076081833, 82.46671515, "38"],
[54.90916225, 82.4659552667, "52"],
[54.90454345, 82.4684433, "1"],
[54.90512805, 82.4671995667, "11A"],
[54.9059193, 82.4674994, "16"],
[54.9073133167, 82.4668277667, "34"],
[54.9102952667, 82.4654520833, "64"],
[54.9092774833, 82.46591125, "52A"],
[54.9052165167, 82.4674315333, "11"],
[54.9053672, 82.4671046, "17B"],
[54.9048409833, 82.46859545, "4"],
[54.905671, 82.46720995, "19"],
[54.9048928333, 82.4683727167, "6"],
[54.9058366833, 82.4671128, "21"],
[54.9071612667, 82.4678683, "30"],
[54.9089840667, 82.4660592667, "50"],
[54.90527545, 82.4667925333, "15"],
[54.90715615, 82.466917, "32A"],
[54.9061779167, 82.4669647333, "25"],
[54.9077133333, 82.4674576833, "36A"],
[54.9104661667, 82.4653805167, "66"],
[54.9051668667, 82.4678703167, "10"],
[54.89370395, 82.47271155, "11"],
[54.8921716167, 82.4721017, "26"],
[54.8935424167, 82.4728224833, "13A"],
[54.8935212, 82.4727174167, "13"],
[54.8937888333, 82.4722797667, "12"],
[54.8944482, 82.4723851667, "2"],
[54.89426415, 82.4731979833, "8/7"],
[54.8944458167, 82.4722873333, "1/2"],
[54.8940236833, 82.4722967667, "8"],
[54.8944464167, 82.47217745, "2/2"],
[54.89289535, 82.4722046, "20"],
[54.8940564, 82.4721777667, "1/8"],
[54.89387485, 82.47305145, "9A"],
[54.8941962833, 82.4734008333, "7/7"],
[54.8940251167, 82.4729672167, "3/7"],
[54.8940147167, 82.4733695833, "5/7"],
[54.8927664833, 82.4726649, "21"],
[54.8940957833, 82.4733820167, "6/7"],
[54.8942063833, 82.47275275, "11/7"],
[54.8938730167, 82.4727318667, "9"],
[54.8940384833, 82.4727499833, "1/7"],
[54.8916949833, 82.47255425, "29"],
[54.8940345667, 82.4728609333, "2/7"],
[54.8920309, 82.4720907167, "28"],
[54.8942669167, 82.4723162, "6"],
[54.8920657333, 82.4725813667, "27"],
[54.8924789, 82.4721364167, "22"],
[54.89162635, 82.4720620167, "34"],
[54.89420475, 82.4728706, "10/7"],
[54.8924279, 82.4726186167, "25"],
[54.8942782, 82.4730613833, "9/7"],
[54.8917478833, 82.4720685333, "32"],
[54.89359425, 82.4722612333, "14"],
[54.8919238167, 82.4717851167, "30A"],
[54.89358685, 82.47297855, "11A"],
[54.8917815667, 82.4717468667, "32A"],
[54.8940195667, 82.4730878667, "4/7"],
[54.89188475, 82.4720793833, "30"],
[54.8766258167, 82.453827333, "63"],
[54.8793250667, 82.4531694667, "33"],
[54.87557575, 82.4531778333, "71"],
[54.8649285167, 82.4537918667, "194"],
[54.8758193333, 82.4536709167, "72"],
[54.8730099333, 82.4536885167, "104"],
[54.87537995, 82.4536875833, "76"],
[54.866365, 82.4537908667, "182"],
[54.8773983, 82.4531370667, "53"],
[54.8663474333, 82.4540325167, "182A"],
[54.8765353, 82.4536952667, "68"],
[54.8633266833, 82.4532383833, "213"],
[54.8748418833, 82.4536900667, "86"],
[54.8723979667, 82.4536811667, "112"],
[54.8789557167, 82.4531799167, "37"],
[54.8744338333, 82.45543435, "88"],
[54.8780606333, 82.4531695167, "49"],
[54.8613876667, 82.4533495833, "1/233"],
[54.8779126333, 82.449236, "4/51"],
[54.86132765, 82.4526138667, "2/233"],
[54.8779974333, 82.45063155, "3/51"],
[54.8629783167, 82.4532700667, "215"],
[54.8777104167, 82.4515755167, "2/51"],
[54.8811745, 82.4555028167, "4"],
[54.8779778833, 82.4521171, "1/51"],
[54.8619675333, 82.4532946667, "227"],
[54.8786639833, 82.4493194167, "5/51"],
[54.88057795, 82.4544579, "18"],
[54.86531615, 82.4531001833, "191"],
[54.8655207167, 82.4536965333, "186"],
[54.8646614333, 82.4537639667, "198"],
[54.8647871333, 82.4541422833, "196"],
[54.86771765, 82.4537268, "162"],
[54.8711387333, 82.4536879167, "124"],
[54.8611343167, 82.45330145, "235"],
[54.8624900167, 82.4532548833, "221"],
[54.86872715, 82.4532476, "151"],
[54.8703843667, 82.4532525, "131"],
[54.8692643833, 82.45371825, "150"],
[54.8699453833, 82.4537083667, "142"],
[54.88075845, 82.4546889, "14"],
[54.8810108833, 82.45510075, "8"],
[54.8808800833, 82.45486695, "12"],
[54.8810951, 82.4553182, "6"],
[54.8812414333, 82.4557114167, "2"],
[54.8737279833, 82.4537149833, "90"],
[54.8804315833, 82.4547993833, "2/16"],
[54.8806571333, 82.4551276833, "2/10"],
[54.8807296667, 82.4552756333, "1/10"],
[54.8805078333, 82.4548978667, "1/16"],
[54.8305417667, 82.4407137167, "106"],
[54.8305758833, 82.4444438667, "78"],
[54.8305754, 82.45156825, "18"],
[54.83063965, 82.45322105, "2"],
[54.8305728333, 82.4437875667, "82"],
[54.8690497667, 82.4740093167, "7"],
[54.86952375, 82.4790699, "60"],
[54.8713118667, 82.4763685667, "42"],
[54.8690602667, 82.4767549167, "47"],
[54.8957648333, 82.4773709167, "4A"],
[54.8971239167, 82.47716665, "16"],
[54.89663135, 82.4774846833, "10"],
[54.8972863333, 82.4770748833, "18"],
[54.8969474167, 82.4772745667, "14"],
[54.8963529167, 82.4776375333, "8"],
[54.8982169667, 82.4746382667, "44"],
[54.8958142, 82.4771743333, "4B"],
[54.89577995, 82.4770061667, "4C"],
[54.8956352667, 82.4772386167, "4"],
[54.89679325, 82.4773878, "12"],
[54.8956875333, 82.4769206, "4D"],
[54.8955368, 82.4771246333, "2"],
[54.9075869833, 82.4681207167, "5"],
[54.9076935833, 82.4688911, "1"],
[54.9078046833, 82.4683225333, "7"],
[54.9077261333, 82.4681354833, "6"],
[54.9078473333, 82.4685627833, "8"],
[54.9075310167, 82.46846565, "3"],
[54.9079180333, 82.46879245, "9"],
[54.90762245, 82.4686683, "2"],
[54.9074934833, 82.4682448, "4"],
[54.8065385167, 82.3969116167, "26"],
[54.8052316167, 82.3947853833, "1"],
[54.8054979333, 82.3951090333, "5"],
[54.8061355333, 82.3955903667, "12"],
[54.8057016167, 82.3950258333, "6"],
[54.8059893667, 82.3953958833, "10"],
[54.8068311167, 82.3965807, "22"],
[54.80583815, 82.3952011167, "8"],
[54.8067129833, 82.3967156, "24"],
[54.8062816833, 82.39578495, "14"],
[54.8056595, 82.3953378, "7"],
[54.80642775, 82.3959857667, "16"],
[54.8067297167, 82.39640035, "20"],
[54.8063663, 82.3962931167, "13"],
[54.8053626333, 82.3949338333, "3"],
[54.8065366, 82.3965265333, "15"],
[54.80539065, 82.394573, "2"],
[54.8065884, 82.39621225, "18"],
[54.8055506833, 82.39481855, "4"],
[54.8062047667, 82.3961045, "11"],
[54.91218215, 82.4768794167, "8"],
[54.9120288167, 82.4765747, "7B"],
[54.9122875167, 82.4765784167, "3"],
[54.9123338833, 82.4771329833, "6B"],
[54.9120254167, 82.4764380167, "5"],
[54.91246155, 82.4769255333, "4"],
[54.9125897333, 82.4768015, "2"],
[54.9121711333, 82.4767164667, "7"],
[54.9122827167, 82.4769958667, "6A"],
[54.8527505833, 82.53393255, "617"],
[54.8826752167, 82.5025520333, "9"],
[54.81291845, 82.5447496, "1161"],
[54.8788362167, 82.510149, "1/88"],
[54.81259405, 82.5447376, "1163"],
[54.8763215167, 82.5110032333, "115"],
[54.8751193167, 82.51276665, "134"],
[54.86748695, 82.5219444167, "272"],
[54.8793489167, 82.5093666167, "80"],
[54.8249454833, 82.5459290333, "1021"],
[54.87870795, 82.5090378667, "81"],
[54.8802461667, 82.5019911, "1/37"],
[54.8790009333, 82.5095332, "84"],
[54.8675435167, 82.51850165, "243"],
[54.8783544, 82.5094524833, "97"],
[54.8785864667, 82.5105412333, "2/88"],
[54.8565379167, 82.5340265667, "567"],
[54.8790696167, 82.5117932, "98"],
[54.8579882167, 82.5332226833, "557"],
[54.8228546333, 82.5478497667, "1043"],
[54.8111895167, 82.5446341667, "1177"],
[54.8670294, 82.5209776667, "265"],
[54.8111449, 82.5438866, "1179"],
[54.8810532167, 82.50530935, "39"],
[54.8107934667, 82.5438973833, "1183"],
[54.8766940333, 82.51263885, "2/110"],
[54.8094178833, 82.5439488333, "1195"],
[54.8484587833, 82.5342090667, "663"],
[54.81064835, 82.5445837167, "1187"],
[54.8744863, 82.5115857333, "139"],
[54.8099838, 82.54453645, "1191"],
[54.8787071333, 82.5051437667, "2/39"],
[54.8092644167, 82.54453125, "1199"],
[54.8361982667, 82.5463852167, "890"],
[54.8389412667, 82.5464548, "858"],
[54.8789616667, 82.5121996833, "100"],
[54.8336715167, 82.5454231, "919"],
[54.8289189, 82.5478054833, "986"],
[54.8323492833, 82.5460591, "928"],
[54.8320521833, 82.5459855, "930"],
[54.8251348833, 82.5480670667, "1016"],
[54.8561845167, 82.5327450833, "581"],
[54.8262207333, 82.5482595333, "996"],
[54.8083614833, 82.5449377833, "1211"],
[54.8172147667, 82.5457622333, "1107"],
[54.8461716667, 82.5348015333, "688"],
[54.8159882, 82.5454072833, "1119"],
[54.8801261, 82.5011647833, "37"],
[54.8788507333, 82.5071659, "5/39"],
[54.86353225, 82.5262979167, "392"],
[54.8087557667, 82.5460182, "1208"],
[54.8799249, 82.50989025, "70"],
[54.8087391167, 82.5453725167, "1206"],
[54.8368114333, 82.5449542167, "881"],
[54.8278101833, 82.5479474667, "990"],
[54.8144593833, 82.5446729333, "1143"],
[54.8763691667, 82.51261455, "1/110"],
[54.8141157667, 82.5446296, "1145"],
[54.8675668333, 82.5223205667, "276"],
[54.86875635, 82.5151021667, "207"],
[54.8785670167, 82.5058547667, "3/39"],
[54.8766803833, 82.5140811167, "6/110"],
[54.86696285, 82.5258656667, "302"],
[54.81135475, 82.5425439833, "1/1181"],
[54.8809864833, 82.5057107, "8/39"],
[54.8788209, 82.5065659833, "4/39"],
[54.8792938833, 82.5065692167, "7/39"],
[54.8139674667, 82.5456240667, "1146"],
[54.8611906333, 82.5269748, "432"],
[54.8402324, 82.5411414667, "809"],
[54.82010205, 82.5480512333, "1070"],
[54.8771378833, 82.51029235, "1/103"],
[54.8213269333, 82.54882125, "1052"],
[54.8089942, 82.5452704833, "1202"],
[54.8212039667, 82.5500653333, "1/1052"],
[54.86704345, 82.5199686167, "257"],
[54.8211860833, 82.55188125, "2/1052"],
[54.8732234167, 82.51193365, "151"],
[54.8231706667, 82.5483519, "1040"],
[54.8129427333, 82.54544965, "1158"],
[54.8398410833, 82.5429798, "817"],
[54.8774619667, 82.5081401333, "4/103"],
[54.8413094333, 82.5414880333, "796"],
[54.8734242333, 82.5114266833, "149"],
[54.8116329167, 82.54465065, "1173"],
[54.8790814667, 82.505419, "6/39"],
[54.8402537, 82.54399925, "830"],
[54.87415495, 82.5111152667, "1/139"],
[54.8090223833, 82.5446570333, "1201"],
[54.8809561333, 82.5036574833, "35"],
[54.8085440167, 82.5454961667, "1210"],
[54.8413132, 82.5395747333, "773"],
[54.87539025, 82.5146704167, "1/138"],
[54.83847385, 82.54218775, "2/815"],
[54.87580405, 82.5118973167, "126"],
[54.86917495, 82.5157794167, "1/208"],
[54.8082772667, 82.5455867333, "1212"],
[54.8096694667, 82.5450804833, "1194"],
[54.8787073667, 82.5083375, "79"],
[54.8763409333, 82.51340955, "3/110"],
[54.8080369167, 82.5450349667, "1213"],
[54.8093666167, 82.5451384833, "1196"],
[54.82245505, 82.5477440333, "1047"],
[54.8775422667, 82.5104792, "2/103"],
[54.8236463333, 82.5474525, "1033"],
[54.8814960667, 82.50479415, "33"],
[54.8245330667, 82.5471272667, "1023"],
[54.8403625, 82.5402170167, "1/809"],
[54.8678366667, 82.5195366167, "254"],
[54.8790242333, 82.5103504333, "4/88"],
[54.8218208, 82.5477814333, "1049"],
[54.8789700833, 82.5084782833, "77/1"],
[54.8704926333, 82.5137601667, "188"],
[54.87878565, 82.5106821667, "3/88"],
[54.871913, 82.5121444333, "163"],
[54.87933595, 82.5101975333, "6/88"],
[54.8748227833, 82.5121225, "136"],
[54.87947495, 82.5108712167, "5/88"],
[54.8753615167, 82.5127019833, "132"],
[54.8109761333, 82.5426080167, "1181"],
[54.8773393667, 82.5116264833, "104"],
[54.8370667667, 82.5458885833, "879"],
[54.8765559833, 82.5101962833, "103"],
[54.8253379167, 82.5472683, "989"],
[54.8793315833, 82.5086546167, "77"],
[54.8661602, 82.52487915, "316"],
[54.8776637333, 82.50929225, "3/103"],
[54.8092819667, 82.5456565833, "2/1200"],
[54.87534805, 82.5120049833, "128"],
[54.81204605, 82.5446423333, "1169"],
[54.8752625833, 82.5140794833, "138"],
[54.8766464333, 82.5134206667, "4/110"],
[54.8770230167, 82.5108992333, "113"],
[54.8406207, 82.5394538167, "2/809"],
[54.8770699833, 82.5116503167, "106"],
[54.8122078667, 82.5440270833, "1165"],
[54.87518925, 82.5112472667, "129"],
[54.8507412333, 82.5347013833, "633"],
[54.8759461833, 82.5110732833, "117"],
[54.8210931833, 82.5477387333, "1055"],
[54.87555235, 82.511829667, "127"],
[54.8180744833, 82.5471867333, "1092"],
[54.8761638, 82.5118200833, "120"],
[54.8714445, 82.5188348833, "2/208"],
[54.8738533, 82.5117649, "141"],
[54.8083899, 82.5443001833, "1209"],
[54.8672468667, 82.5243000167, "295"],
[54.8395333333, 82.54262905, "1/815"],
[54.8093977833, 82.5456164833, "1/1200"],
[54.86778915, 82.5240579167, "290"],
[54.8151683, 82.5450954333, "1133"],
[54.8676913333, 82.5179285833, "235"],
[54.87977015, 82.5090145833, "66"],
[54.8785379333, 82.5043763, "1/39"],
[54.8764341333, 82.51407215, "5/110"],
[54.8740516, 82.5125295667, "146"],
[54.87401495, 82.47760185, "16"],
[54.8739528333, 82.4764705667, "31"],
[54.8739846167, 82.4768385667, "33"],
[54.8748585167, 82.4767720333, "11"],
[54.8736880333, 82.4772042167, "37"],
[54.8747492333, 82.4769483667, "9"],
[54.87503235, 82.4775088667, "3"],
[54.87489515, 82.4779213833, "6"],
[54.8748158667, 82.4774378, "5"],
[54.8750760667, 82.4779026, "4"],
[54.8746501167, 82.4773401167, "7"],
[54.8741460667, 82.4765724167, "27"],
[54.8739166167, 82.477184, "35"],
[54.8741975833, 82.4778215, "23"],
[54.8738094, 82.47760075, "18"],
[54.8749257833, 82.4765688833, "13"],
[54.8741402667, 82.4763856, "29"],
[54.8742506833, 82.4775977, "14"],
[54.8741505, 82.47681925, "25"],
[54.8747261167, 82.4778583667, "8"],
[54.8745555, 82.4777541667, "10"],
[54.8743982667, 82.4777232, "12"],
[54.87440735, 82.4772111833, "21"],
[54.8745958667, 82.47674675, "19"],
[54.8747628333, 82.47645865, "15"],
[54.8745715333, 82.4764928667, "17"],
[54.9116880667, 82.4711713833, "3"],
[54.9116604333, 82.4715114333, "1"],
[54.9118500667, 82.4714183, "5"],
[54.9122240667, 82.4713923, "11"],
[54.9118788833, 82.4710693167, "7"],
[54.9123174667, 82.4714676167, "10"],
[54.91227905, 82.4716167167, "8"],
[54.9117270667, 82.4718080667, "2"],
[54.91205, 82.4713633167, "9"],
[54.912161, 82.4717712, "6"],
[54.8859179333, 82.4582119667, "1"],
[54.8865885333, 82.4581321667, "6A"],
[54.88640305, 82.45807455, "6"],
[54.8860451667, 82.4578916833, "4D"],
[54.8863091167, 82.45790615, "5"],
[54.8861527, 82.4579021833, "4A"],
[54.8859058833, 82.4578780333, "3"],
[54.8861333333, 82.4577295167, "4B"],
[54.8859079333, 82.45834695, "1A"],
[54.8861985, 82.4582370667, "7"],
[54.8860742333, 82.4577260833, "4C"],
[54.8858135, 82.4580266333, "2"],
[54.8856798, 82.4576616167, "3B"],
[54.8857954333, 82.45773405, "3A"],
[54.8039755167, 82.3924264333, "588"],
[54.8024268333, 82.3891336167, "555"],
[54.80621375, 82.3790952, "476A"],
[54.8035793667, 82.3898201333, "565"],
[54.8041731333, 82.3674844, "348"],
[54.8035751833, 82.38904805, "559"],
[54.8013125167, 82.390194, "569A"],
[54.8039518333, 82.3880558333, "550"],
[54.7993036333, 82.3774681, "447B"],
[54.80163095, 82.39138825, "577"],
[54.8035939833, 82.3922268667, "583"],
[54.8034719167, 82.3864473333, "535A"],
[54.80612815, 82.3786574833, "476C"],
[54.80604375, 82.3653441833, "320"],
[54.8030940833, 82.3837668333, "515"],
[54.8017065167, 82.37966555, "471"],
[54.8032808167, 82.3824573833, "496C"],
[54.8023511333, 82.3675479833, "361"],
[54.8029974167, 82.38875325, "553B"],
[54.8013158, 82.3713298333, "400"],
[54.8069269167, 82.38494245, "522A"],
[54.8041518333, 82.3666512333, "342"],
[54.8035926, 82.3904181, "569B"],
[54.8022781333, 82.3782524667, "450A"],
[54.8010726667, 82.3710681167, "395"],
[54.80130715, 82.37668905, "445"],
[54.8010362667, 82.3712212667, "399"],
[54.8032196333, 82.36794415, "358"],
[54.80095265, 82.3727210333, "409"],
[54.8021615667, 82.3808655833, "481B"],
[54.80149165, 82.3733540167, "418"],
[54.8010327833, 82.3739455167, "419"],
[54.8037261333, 82.3859318333, "530"],
[54.8019531333, 82.36978095, "382"],
[54.8035854333, 82.3674296167, "352"],
[54.8035820667, 82.3681635, "358B"],
[54.8044532833, 82.3898220167, "562A"],
[54.8030543167, 82.3681729333, "360"],
[54.80023085, 82.3753558333, "429B"],
[54.8029366333, 82.3683441833, "362"],
[54.8046987, 82.38796795, "548"],
[54.80282455, 82.3684962, "364"],
[54.8016347167, 82.3738360667, "420"],
[54.8031052333, 82.3689649333, "366"],
[54.8026689, 82.3687241167, "368"],
[54.8025527333, 82.3689042333, "370"],
[54.8037381333, 82.3672040667, "350B"],
[54.8015959333, 82.37030475, "384"],
[54.8037429667, 82.3861631667, "532"],
[54.8056256, 82.3854121, "522D"],
[54.8074032833, 82.37890055, "476D"],
[54.8033627833, 82.3941313, "601"],
[54.8035645833, 82.3885777333, "553A"],
[54.8037265833, 82.3751864333, "438"],
[54.80393295, 82.3820938333, "496B"],
[54.8039961667, 82.3937407167, "600"],
[54.8016335, 82.3785741333, "455B"],
[54.8028840667, 82.3674978, "357"],
[54.8009541833, 82.3783785, "455C"],
[54.8061105, 82.3849712833, "518"],
[54.8041071, 82.3675672667, "350A"],
[54.8039732667, 82.3922047667, "586"],
[54.7970054833, 82.3806949833, "475B"],
[54.80154115, 82.3776200833, "455A"],
[54.7968634833, 82.3813122667, "475C"],
[54.8040230333, 82.3951761833, "610"],
[54.8004082667, 82.3807690333, "475D"],
[54.8020559, 82.3804593667, "481A"],
[54.8029026667, 82.3814678667, "490"],
[54.79877225, 82.3804673833, "475A"],
[54.8024990833, 82.3803016, "478"],
[54.80798195, 82.3848864167, "522B"],
[54.8032268667, 82.3820611833, "496A"],
[54.8039424333, 82.3900004667, "566"],
[54.8055885667, 82.3849529667, "508"],
[54.8039439833, 82.3902647333, "568"],
[54.8044673167, 82.3791537667, "476B"],
[54.8034701, 82.3861407833, "531"],
[54.80394855, 82.3905212833, "570"],
[54.8033434667, 82.3677650667, "356"],
[54.8039541167, 82.3897445, "564"],
[54.8044864833, 82.3894950833, "562B"],
[54.8023883667, 82.3792474, "468"],
[54.8037905667, 82.3868461833, "538"],
[54.80376065, 82.3848380167, "516"],
[54.8037788333, 82.3866195333, "536"],
[54.8013236667, 82.3867703833, "535B"],
[54.80376085, 82.3863884, "534"],
[54.8038128667, 82.38531645, "524"],
[54.8038359, 82.3875590667, "546"],
[54.8053126, 82.3651698, "328"],
[54.8038053833, 82.3870689, "540"],
[54.80589585, 82.3892222167, "560"],
[54.8035248667, 82.3876434167, "545"],
[54.8037198, 82.3949872, "609"],
[54.80381955, 82.3872982, "542"],
[54.8075598333, 82.3855587, "522C"],
[54.8039602167, 82.3917614333, "582"],
[54.80139505, 82.3727005667, "414"],
[54.8036690667, 82.3910398667, "575"],
[54.8039518833, 82.3910117167, "574"],
[54.80395405, 82.3914879333, "580"],
[54.8002672167, 82.3771908, "447A"],
[54.8039521833, 82.3907747167, "572"],
[54.8036402667, 82.3914460167, "579"],
[54.803952, 82.3912312333, "578"],
[54.8015263667, 82.3694650333, "383"],
[54.80400045, 82.3949203833, "608"],
[54.8039955333, 82.3935219167, "598"],
[54.8039738167, 82.3926465167, "590"],
[54.8034657167, 82.3675994, "354"],
[54.8039642833, 82.3919945, "584"],
[54.8039832667, 82.3932899167, "596"],
[54.7988289, 82.3754860833, "429C"],
[54.80369095, 82.3927310167, "591"],
[54.80233225, 82.3911433833, "571"],
[54.8039846667, 82.3930810833, "594"],
[54.8013068333, 82.37155805, "402"],
[54.80397775, 82.3928504167, "592"],
[54.8040068833, 82.3948069833, "608A"],
[54.8037325167, 82.3941101167, "603"],
[54.8021858833, 82.3685292167, "369"],
[54.8039958, 82.3939723167, "602"],
[54.8048039833, 82.3657911, "336"],
[54.80368355, 82.39362055, "599"],
[54.8039906833, 82.3668667833, "344"],
[54.8037408333, 82.39457725, "607"],
[54.8040022167, 82.3941957, "604"],
[54.80357305, 82.3683457167, "358A"],
[54.80400475, 82.3944321167, "606"],
[54.8037340667, 82.3943487167, "605"],
[54.8021156667, 82.3876556833, "543"],
[54.8012321, 82.3754553833, "429A"],
[54.8018551667, 82.3752511, "430"],
[54.8038677333, 82.3670357333, "346"],
[54.8037207167, 82.3857282667, "528"],
[54.89186715, 82.4802623167, "40"],
[54.8923304833, 82.4777135167, "13"],
[54.8929612833, 82.4756593333, "1"],
[54.8918642, 82.4800987833, "38"],
[54.8926700333, 82.4763031833, "5"],
[54.89194195, 82.47893395, "28A"],
[54.8924575833, 82.4767435167, "9"],
[54.8918917333, 82.47938125, "32"],
[54.8922351667, 82.4796796333, "27"],
[54.8916363333, 82.47957795, "34A"],
[54.8922002833, 82.48006775, "29"],
[54.8918962833, 82.4796114333, "34"],
[54.8923002333, 82.4783952667, "21"],
[54.89225505, 82.4790280833, "25"],
[54.8920123333, 82.4773945167, "10"],
[54.8919046167, 82.4791651833, "30"],
[54.89170475, 82.4789158833, "28B"],
[54.89166225, 82.4793545667, "32A"],
[54.8919418833, 82.4787236, "26"],
[54.89187395, 82.4798382833, "36"],
[54.89226945, 82.4788097167, "23"],
[54.8919833667, 82.47800955, "14"],
[54.88193185, 82.4866305833, "1"],
[54.8812478, 82.4878395, "20"],
[54.8819307, 82.48686775, "3"],
[54.8823734333, 82.4877629833, "8B"],
[54.8821842833, 82.48700355, "4"],
[54.8818976833, 82.4871309333, "5"],
[54.8821982333, 82.4867615167, "2"],
[54.8821772, 82.48722635, "6"],
[54.8809340667, 82.4875154, "24"],
[54.8815621333, 82.4870228333, "11B"],
[54.88080855, 82.4873367167, "26"],
[54.8810877167, 82.4876951, "22"],
[54.8806647833, 82.4872178, "25"],
[54.8815580667, 82.4875735333, "9"],
[54.88050695, 82.48709835, "23"],
[54.8823652833, 82.48799725, "10B"],
[54.8817490333, 82.4878626667, "12"],
[54.88214405, 82.4874454833, "8"],
[54.8816923833, 82.4878766167, "14"],
[54.8823520667, 82.4875880667, "8A"],
[54.8814424167, 82.48790665, "16"],
[54.8819485333, 82.48774405, "10"],
[54.8813723833, 82.4878899, "18"],
[54.8822010167, 82.4879131167, "10A"],
[54.8825377667, 82.48796795, "8C"],
[54.8808839, 82.4866251333, "17"],
[54.8807889, 82.4868384833, "19"],
[54.8806788833, 82.4869695333, "21"],
[54.8818035, 82.48743315, "7"],
[54.8810684667, 82.4871791, "13"],
[54.8809503667, 82.4869225, "15"],
[54.8812931167, 82.4874573167, "11"],
[54.8812351167, 82.4869114833, "13A"],
[54.8814375667, 82.4871747, "11A"],
[54.8813577333, 82.4869692333, "13B"],
[54.9359592833, 82.5576784333, "1/21"],
[54.9380472167, 82.5564234833, "20"],
[54.9388147833, 82.5583222333, "2/21"],
[54.9370746333, 82.55679275, "21"],
[54.9396807833, 82.5590516333, "4/21"],
[54.9321653667, 82.5586632333, "15"],
[54.93777925, 82.5607732333, "3/21"],
[54.93261665, 82.5577030167, "22"],
[54.9350610667, 82.5544772, "18"],
[54.9324680333, 82.55825425, "17"],
[54.93286725, 82.5580919667, "19"],
[54.9655341, 82.48344125, "228"],
[54.9662557833, 82.4823937167, "238"],
[54.9551121167, 82.4819800167, "74"],
[54.97145005, 82.4810869667, "298"],
[54.96511045, 82.4842071167, "226"],
[54.9597843, 82.4837558833, "1/144"],
[54.9542875333, 82.4787352833, "46"],
[54.96095, 82.4848569, "156"],
[54.9608395667, 82.4825922167, "144"],
[54.9665397, 82.4859805667, "227"],
[54.9546337667, 82.4780326167, "44"],
[54.9662588833, 82.48466365, "229"],
[54.9774811333, 82.4827824167, "367"],
[54.9532187667, 82.4778035833, "25"],
[54.9779600167, 82.4820124333, "380"],
[54.96688945, 82.4825700833, "244"],
[54.9724996333, 82.4816797, "317"],
[54.9551293333, 82.4882803333, "2/81"],
[54.9544212167, 82.4829611333, "79"],
[54.9552378333, 82.4835594, "3/81"],
[54.9551674833, 82.4873534333, "1/81"],
[54.8177678333, 82.36481165, "23"],
[54.8176856667, 82.36528815, "21"],
[54.81793065, 82.36431665, "24"],
[54.8188466, 82.3655251167, "13"],
[54.8183913167, 82.3654774833, "14"],
[54.8186506667, 82.3663757833, "8"],
[54.9091586833, 82.4806199667, "8"],
[54.9097846667, 82.4804238833, "5"],
[54.9095970833, 82.4803937333, "6"],
[54.90949585, 82.48088805, "2"],
[54.9097125667, 82.4807851667, "3"],
[54.9090767333, 82.4810419167, "1"],
[54.9098378, 82.4806015167, "4"],
[54.9094125333, 82.48047265, "7"],
[54.8987957167, 82.4867648167, "4"],
[54.8993040833, 82.48608325, "13A"],
[54.8986618667, 82.4863548, "3"],
[54.8990157167, 82.4866799667, "8"],
[54.8988486167, 82.48625515, "11"],
[54.89940275, 82.48652375, "12"],
[54.8990940333, 82.4857358333, "15"],
[54.8994477, 82.4860294167, "13"],
[54.8984905333, 82.4864897167, "1"],
[54.8910458667, 82.4604486167, "4A"],
[54.8909012833, 82.4603024667, "1"],
[54.8912700667, 82.4604892667, "4B"],
[54.8909202167, 82.4608893333, "3C"],
[54.8912779333, 82.4605982333, "4C"],
[54.8909172, 82.4610096, "3D"],
[54.8910309833, 82.46058295, "4D"],
[54.8909275167, 82.4607770667, "3B"],
[54.8908830667, 82.46040695, "2"],
[54.8907294667, 82.4603703, "2B"],
[54.8909360167, 82.4606728333, "3A"],
[54.8910318, 82.46011345, "5"],
[54.9038995167, 82.4740167833, "1"],
[54.9040010833, 82.4744881, "3"],
[54.9039700667, 82.4742456667, "2"],
[54.9041160333, 82.4738995667, "9"],
[54.9042205, 82.4746609667, "5"],
[54.90408835, 82.4746666167, "4"],
[54.9043300333, 82.4745611833, "6"],
[54.9042862667, 82.47435, "7"],
[54.9041895, 82.4741327333, "8"],
[54.8412972333, 82.51498905, "2/370"],
[54.85380915, 82.5048969, "197"],
[54.8393792167, 82.5185004833, "4/370"],
[54.8356004, 82.5155473833, "1/446"],
[54.8516975167, 82.5088596333, "230"],
[54.83493705, 82.5162245, "2/446"],
[54.8630868833, 82.5013258667, "77"],
[54.8341336333, 82.5147212667, "454"],
[54.838285167, 82.511789, "495"],
[54.8378645667, 82.51179665, "422"],
[54.8482979667, 82.5057717167, "2/277"],
[54.8384529, 82.5107566, "1/413"],
[54.8543168833, 82.5057733167, "200"],
[54.8382859, 82.51004915, "2/413"],
[54.8302591667, 82.51099635, "520"],
[54.8430264833, 82.5117441667, "361"],
[54.8569890167, 82.50014995, "145"],
[54.8546612333, 82.51046255, "4/210"],
[54.8291138167, 82.5100652833, "537"],
[54.8644712, 82.5010749167, "57"],
[54.8537165667, 82.5061015667, "1/210"],
[54.8561494333, 82.5002218833, "151"],
[54.8531273167, 82.50591205, "207"],
[54.8661337333, 82.50044185, "39"],
[54.8572501333, 82.50068855, "142"],
[54.86749845, 82.4999983667, "31"],
[54.8311046167, 82.5124198667, "504"],
[54.8610681167, 82.5009140667, "99"],
[54.86009745, 82.5013829333, "110"],
[54.8635882333, 82.5025296333, "2/72"],
[54.8381455333, 82.5095623833, "415"],
[54.86345265, 82.5022295333, "1/72"],
[54.8535591333, 82.5063429, "3/210"],
[54.8428438667, 82.5239404333, "8/370"],
[54.8425296667, 82.5133880833, "1/370"],
[54.8415704667, 82.5230515333, "7/370"],
[54.8607450167, 82.5008543833, "101"],
[54.8402798167, 82.5220041667, "6/370"],
[54.8540611833, 82.5052768833, "198"],
[54.8457524833, 82.5094666, "314"],
[54.8379597667, 82.51065885, "417"],
[54.83947605, 82.5206863, "5/370"],
[54.8301105, 82.5103759, "521"],
[54.84097385, 82.5217665167, "9/370"],
[54.8408829167, 82.5157633333, "3/370"],
[54.8540650833, 82.5067036667, "2/210"],
[54.8541100167, 82.5042267333, "191"],
[54.8426532167, 82.5117339667, "365"],
[54.8483104167, 82.50609355, "1/277"],
[54.8610126167, 82.5014974, "98"],
[54.8409556, 82.5110372667, "383"],
[54.8563855167, 82.4999012333, "149"],
[54.8591389167, 82.5012515167, "118"],
[54.8622922667, 82.5017081, "86"],
[54.8279955333, 82.5107170333, "548"],
[54.8293633667, 82.5100288667, "535"],
[54.87412315, 82.36871325, "20"],
[54.8741985167, 82.3678984333, "25"],
[54.8744552833, 82.36791385, "23"],
[54.82354435, 82.3645601333, "31"],
[54.81426245, 82.3697857667, "140B"],
[54.8249820167, 82.36436295, "18A"],
[54.8247545333, 82.3644630667, "18B"],
[54.8196718, 82.3690864167, "74B"],
[54.8141992167, 82.3685047667, "140D"],
[54.8202965167, 82.3688420833, "74C"],
[54.8180317333, 82.3670563833, "97"],
[54.8166606, 82.3680389833, "116"],
[54.81378495, 82.3674693667, "143"],
[54.8140329833, 82.36750105, "141"],
[54.8230129333, 82.36477085, "33"],
[54.8181065333, 82.367528, "96A"],
[54.822355, 82.3651528333, "43"],
[54.8207430167, 82.37001735, "72"],
[54.882852333, 82.36768535, "104"],
[54.8240652167, 82.3643383167, "25"],
[54.8208649167, 82.3708165167, "72C"],
[54.8158759333, 82.3699935167, "124A"],
[54.81611735, 82.3726213833, "124D"],
[54.8141102833, 82.3710208167, "140E"],
[54.8158552833, 82.3725671, "126C"],
[54.8172870667, 82.3672759333, "105"],
[54.8149043167, 82.3680942, "126A"],
[54.8156860667, 82.3714600667, "126B"],
[54.82234555, 82.3676551167, "58C"],
[54.8229201, 82.3663306333, "42B"],
[54.8217244667, 82.36615365, "56"],
[54.82168065, 82.3671740333, "58A"],
[54.8226533, 82.3656960667, "42A"],
[54.81969495, 82.3671185, "74A"],
[54.8139910833, 82.3680670333, "142"],
[54.8222810667, 82.36812165, "58B"],
[54.8160942833, 82.3717498333, "124C"],
[54.8210101167, 82.3697359333, "72D"],
[54.8199424667, 82.3700336667, "72A"],
[54.8162840333, 82.36763115, "115"],
[54.8169082, 82.3674243667, "109"],
[54.8231334167, 82.3666729833, "42C"],
[54.8211535833, 82.3664307, "66"],
[54.8159958, 82.3710006, "124B"],
[54.8230926333, 82.3654223667, "40"],
[54.8142580167, 82.3692795333, "140C"],
[54.8184104667, 82.3677529833, "96B"],
[54.8232137667, 82.3664941667, "42D"],
[54.8238653167, 82.3649438333, "30"],
[54.8210668833, 82.3659746167, "59"],
[54.8204322833, 82.3668945833, "70"],
[54.814820667, 82.3703629167, "140A"],
[54.8203761167, 82.3663, "69"],
[54.8190875, 82.3666263, "83"],
[54.8206303833, 82.37079745, "72B"],
[54.8159921167, 82.36829495, "120"],
[54.8702900833, 82.4823576, "129"],
[54.8691575833, 82.4875552167, "174"],
[54.8752810167, 82.4785701333, "29"],
[54.8739353333, 82.4787035333, "71"],
[54.8694349833, 82.4853619333, "150"],
[54.86819925, 82.4904272667, "203"],
[54.8739757333, 82.4791716, "36"],
[54.8743164833, 82.47849545, "69"],
[54.8764327833, 82.4784211167, "18"],
[54.8772371, 82.47724965, "11"],
[54.8711581167, 82.4812798, "99"],
[54.8774015333, 82.4771253167, "9"],
[54.8747281, 82.4786202833, "35"],
[54.8769075, 82.47753225, "15"],
[54.8764091, 82.4779333667, "21"],
[54.8751066833, 82.47903655, "28"],
[54.8755713333, 82.4789569333, "24"],
[54.8767426833, 82.4776735667, "17"],
[54.87754365, 82.4769945167, "7"],
[54.8749176, 82.4790524, "30"],
[54.86789545, 82.4922832833, "215"],
[54.8762449333, 82.4780463833, "23"],
[54.8746104333, 82.4786632333, "37"],
[54.87535045, 82.4789887, "26"],
[54.8690190833, 82.4889257667, "188"],
[54.8766569, 82.4782477833, "16"],
[54.8777791667, 82.4743660833, "3F"],
[54.8760992833, 82.4781375667, "25"],
[54.8735414833, 82.4792975667, "40"],
[54.8749123833, 82.4786099333, "33"],
[54.8778868667, 82.4755309333, "3B"],
[54.8757382667, 82.4789290833, "22"],
[54.8690839, 82.4882992333, "182"],
[54.8778719167, 82.4752090167, "3C"],
[54.8692440333, 82.487114, "168"],
[54.87786735, 82.4759980333, "3A"],
[54.8750885833, 82.4785857167, "31"],
[54.8778593, 82.4767417, "1"],
[54.8770541, 82.4774016167, "13"],
[54.8693264333, 82.4864033167, "160"],
[54.8776720667, 82.47687455, "5"],
[54.87418305, 82.4791450333, "34"],
[54.8772782167, 82.4778079333, "12"],
[54.8694907, 82.48387845, "139"],
[54.8737682833, 82.4792036833, "38"],
[54.8780202167, 82.4743749, "3E"],
[54.87657365, 82.4778033833, "19"],
[54.8769227, 82.4780192833, "14"],
[54.8778372, 82.4747625833, "3D"],
[54.9058634167, 82.4818391833, "11"],
[54.90651765, 82.4816564, "7"],
[54.90600205, 82.4817922833, "10"],
[54.9065382667, 82.4819836667, "6"],
[54.9064549667, 82.48231495, "4"],
[54.9065751, 82.4821868667, "5"],
[54.9062895, 82.4822382667, "3"],
[54.9061909, 82.4817668, "9"],
[54.9058636333, 82.4821877667, "1"],
[54.90609375, 82.48208955, "2"],
[54.9063477667, 82.4818540833, "8"],
[54.9028285, 82.4830620667, "10"],
[54.9033403333, 82.4828242833, "4"],
[54.9026557833, 82.4836036833, "11"],
[54.9026651667, 82.4831392167, "12"],
[54.9024793, 82.4836898833, "13"],
[54.9024864833, 82.4832286333, "14"],
[54.9022771167, 82.4837931167, "15"],
[54.9023275333, 82.48331475, "16"],
[54.9021481167, 82.4833864333, "18"],
[54.9034164167, 82.48324155, "3"],
[54.9020819667, 82.4837508833, "17"],
[54.9032251, 82.4833323833, "5"],
[54.9031833833, 82.4829241667, "6"],
[54.9030398667, 82.4834288667, "7"],
[54.9030060333, 82.4827531167, "8A"],
[54.90303195, 82.4830065, "8"],
[54.90285465, 82.48352545, "9"],
[54.9030180333, 82.4855010667, "50"],
[54.90297345, 82.4847805333, "52"],
[54.90302055, 82.4852138333, "50A"],
[54.9006098833, 82.4854521833, "33"],
[54.9029307667, 82.485268, "48"],
[54.9014686667, 82.48551475, "36"],
[54.9017719833, 82.4853557833, "40"],
[54.9016177667, 82.4854306833, "38"],
[54.9023493667, 82.48468465, "47"],
[54.9027064667, 82.4842364667, "51A"],
[54.9019256667, 82.4852900333, "42"],
[54.9016388667, 82.4849819167, "41"],
[54.9014681667, 82.485061, "39"],
[54.9033233167, 82.48461845, "56"],
[54.9037893833, 82.4839462667, "63"],
[54.9031498833, 82.4846976667, "54"],
[54.9026018, 82.48495995, "44"],
[54.9030769833, 82.4842938, "55"],
[54.9027864167, 82.4848613, "46"],
[54.9037959667, 82.4843982667, "62"],
[54.90251565, 82.4845560333, "49"],
[54.9039613167, 82.4843144, "64"],
[54.9027125667, 82.4844694167, "51"],
[54.9034637167, 82.4841226, "59"],
[54.9028946833, 82.4843869, "53"],
[54.9036489333, 82.4840298833, "61"],
[54.90327315, 82.4842082833, "57"],
[54.90046945, 82.4855198667, "29"],
[54.9010344833, 82.4856939833, "34"],
[54.9013283667, 82.4851346333, "37"],
[54.9017672167, 82.4849186, "43"],
[54.8611247, 82.4102509167, "82"],
[54.8499004667, 82.4102191667, "47"],
[54.86802365, 82.4100161, "251"],
[54.8527479167, 82.4097375667, "82"],
[54.84663775, 82.41026955, "13"],
[54.8556193, 82.4102112167, "113"],
[54.8623374833, 82.4096021667, "188"],
[54.8570313833, 82.4097304667, "128"],
[54.8508672833, 82.4096890333, "58"],
[54.8633539667, 82.4102016833, "197"],
[54.8624295167, 82.4113314833, "187"],
[54.8643999167, 82.4142555167, "211A"],
[54.8674836667, 82.4109264333, "245A"],
[54.8645949333, 82.4142231333, "211B"],
[54.863722, 82.4116543667, "203"],
[54.8652689, 82.4102405667, "217"],
[54.8674028167, 82.4119272333, "245B"],
[54.8688986, 82.4071594333, "283"],
[54.8626189667, 82.4102669333, "191"],
[54.86890705, 82.4066821333, "285"],
[54.8638613833, 82.4102196333, "205"],
[54.8520415333, 82.4096858833, "74"],
[54.85366185, 82.4103740333, "91"],
[54.8541498167, 82.4102157, "99"],
[54.8481882167, 82.4096517333, "32"],
[54.8998180833, 82.4671585833, "1"],
[54.8994876333, 82.46689395, "4"],
[54.8995568833, 82.4671854, "2"],
[54.89982245, 82.4669492, "3"],
[54.8997823167, 82.4667780333, "5"],
[54.8993499, 82.4665456333, "6"],
[54.8994541, 82.4664421167, "8"],
[54.8996415, 82.4667272333, "7"],
[54.8916384833, 82.4630697, "40"],
[54.8913306, 82.4610441333, "24"],
[54.89161595, 82.4716677667, "133"],
[54.8914569167, 82.4754211833, "149"],
[54.89160835, 82.4718250167, "135"],
[54.89234715, 82.4585814667, "9"],
[54.8915247667, 82.4732450833, "137"],
[54.8916493667, 82.4628682, "36"],
[54.89127365, 82.4608001667, "1/20-3/20"],
[54.8922152167, 82.4605929667, "17"],
[54.89145415, 82.4607833333, "4/20-7/20"],
[54.8917261333, 82.4624021, "32"],
[54.8919335167, 82.45821125, "4C"],
[54.8922107833, 82.4609609833, "21"],
[54.8919453667, 82.4579664333, "4B"],
[54.8915077, 82.4658864333, "66"],
[54.8919506333, 82.4577320333, "4A"],
[54.8916613167, 82.4626608667, "34"],
[54.8919576833, 82.4575137, "2C"],
[54.89126035, 82.4701749167, "92"],
[54.8922950667, 82.4588386, "11"],
[54.8921412333, 82.4623956833, "31"],
[54.8918877167, 82.4588751167, "10"],
[54.8912372, 82.4708680333, "98"],
[54.8920993333, 82.4636887167, "43"],
[54.89223965, 82.4603451, "15"],
[54.8920777333, 82.4638900667, "43A"],
[54.89235135, 82.4580704, "5"],
[54.8916213667, 82.4634083333, "44"],
[54.8913535, 82.4751499333, "147"],
[54.8911645667, 82.4634580167, "46"],
[54.89154565, 82.460355, "16A"],
[54.8916286667, 82.4636265667, "48"],
[54.8914890667, 82.4661530833, "68"],
[54.8916243333, 82.46377045, "50A"],
[54.8921945667, 82.4613726833, "25"],
[54.8916212333, 82.4638566667, "50"],
[54.898285833, 82.4617233333, "28"],
[54.8916201, 82.4640203, "52"],
[54.89219925, 82.46119465, "23"],
[54.891597, 82.46425765, "54"],
[54.8918353, 82.46017655, "14"],
[54.8919748667, 82.4649644667, "53"],
[54.8917905667, 82.4608055333, "22"],
[54.89131955, 82.4756406, "153"],
[54.8923704333, 82.4576240833, "3"],
[54.8905614333, 82.4758690167, "154"],
[54.8916816167, 82.4707503, "97"],
[54.8913018667, 82.4759012333, "155"],
[54.89253265, 82.4612154167, "23B"],
[54.8909466833, 82.4760167333, "156"],
[54.8920906167, 82.4634921, "41"],
[54.8912217, 82.4774480833, "165"],
[54.8921237833, 82.46277795, "35"],
[54.8908697333, 82.477294, "162"],
[54.8920948667, 82.4632665833, "39"],
[54.8912003333, 82.47770905, "167"],
[54.8914414833, 82.4678414, "76"],
[54.8908453833, 82.4777106667, "168"],
[54.8912160667, 82.4629456833, "38"],
[54.8911874, 82.4779408167, "169"],
[54.8919186333, 82.4584176833, "6"],
[54.89118215, 82.4781761167, "171"],
[54.8916446833, 82.4632172667, "42"],
[54.8911654333, 82.4784059833, "173"],
[54.8918217333, 82.4603906, "16"],
[54.8911525333, 82.47862755, "82"],
[54.8924511333, 82.4606313, "17B"],
[54.8907954, 82.4784089, "176"],
[54.8915381333, 82.46524225, "58"],
[54.8911355667, 82.478864, "177"],
[54.892167, 82.4617876833, "29"],
[54.8911190667, 82.4790793167, "179"],
[54.89148925, 82.47413605, "141"],
[54.891102, 82.4793148833, "181"],
[54.89174025, 82.4622023, "30"],
[54.8910930167, 82.4795416333, "183"],
[54.8923048, 82.4605938667, "17A"],
[54.8907614, 82.4793265833, "184"],
[54.8919164833, 82.45868485, "8"],
[54.89108015, 82.4797723833, "185"],
[54.8905659667, 82.4757830667, "152"],
[54.8910595667, 82.4800169167, "187"],
[54.8923372333, 82.4582542, "7"],
[54.8917307333, 82.46930505, "83"],
[54.8909663333, 82.4756883833, "150"],
[54.8909111167, 82.47660485, "160"],
[54.8916525667, 82.47116215, "129"],
[54.8909366167, 82.4762755333, "158"],
[54.8911956, 82.4715676333, "104"],
[54.8915429, 82.4650714667, "56"],
[54.8916859833, 82.45866365, "8A"],
[54.8919523, 82.4651683833, "55"],
[54.8915248667, 82.4654342167, "60"],
[54.8917482, 82.4613051333, "26"],
[54.89101255, 82.4753879, "148"],
[54.8925110833, 82.4608349833, "19"],
[54.89179885, 82.4605882333, "18"],
[54.8918582667, 82.4680386, "79"],
[54.8921763167, 82.461584, "27"],
[54.8914747833, 82.4665362167, "70"],
[54.8923905833, 82.4611956167, "23A"],
[54.8919975333, 82.4651655, "55A-55E"],
[54.8920026167, 82.45729865, "2B"],
[54.8920162667, 82.4570673, "2A"],
[54.8916384333, 82.4713722, "131"],
[54.8912288333, 82.4711408333, "102"],
[54.8915248167, 82.4656389833, "62"],
[54.8917611667, 82.46114545, "26A"],
[54.8921091, 82.4630288167, "37"],
[54.8209873167, 82.3760669333, "191C"],
[54.8249917, 82.3656036667, "91A"],
[54.8190006167, 82.3860204167, "254B"],
[54.818206, 82.38533, "254C"],
[54.8061591667, 82.3983436, "462"],
[54.8056489333, 82.3937574167, "423"],
[54.79713005, 82.40084965, "545"],
[54.79324805, 82.4048036667, "601"],
[54.8186617833, 82.3815952, "248A"],
[54.8090422833, 82.3906621333, "383B"],
[54.8183971667, 82.3818555667, "248B"],
[54.8027335833, 82.3963706167, "471"],
[54.8167087, 82.380828333, "267D"],
[54.7975265333, 82.4015703333, "548"],
[54.8190651167, 82.3786646333, "229"],
[54.7903981, 82.4069922833, "639B"],
[54.8253436333, 82.3662536, "91B"],
[54.8085089, 82.3916918167, "406"],
[54.82507135, 82.36734685, "107A"],
[54.8243141667, 82.3677190167, "107B"],
[54.8240930167, 82.3684544333, "107C"],
[54.82428045, 82.3692349, "107D"],
[54.79320855, 82.4054745333, "606"],
[54.8210957833, 82.3758549, "191A"],
[54.8220672667, 82.3711244167, "155B"],
[54.7905658333, 82.40715725, "639A"],
[54.8219987167, 82.37182365, "155C"],
[54.79282425, 82.4050586, "605"],
[54.8217745833, 82.37222335, "155D"],
[54.80515685, 82.3938695, "437"],
[54.8076407333, 82.3900775, "397"],
[54.8237106, 82.3712966333, "131"],
[54.8015971, 82.3955181667, "479"],
[54.8227929, 82.3730921167, "157"],
[54.7961391167, 82.4003037, "549"],
[54.8233609833, 82.37310895, "152"],
[54.8219492667, 82.3745148667, "167"],
[54.8247903833, 82.3685883333, "109"],
[54.8248283, 82.3705193167, "126"],
[54.8109710333, 82.3856751167, "341"],
[54.82605485, 82.3651553667, "80"],
[54.8107359, 82.3894516833, "368"],
[54.8120085667, 82.3845064, "321"],
[54.8128636833, 82.38379265, "310"],
[54.81208235, 82.3843228, "319"],
[54.8046513333, 82.3956590833, "452"],
[54.8144067333, 82.3816008667, "275"],
[54.8102773, 82.3874213, "345B"],
[54.8144369, 82.38227185, "280"],
[54.8164895333, 82.3782892333, "267C"],
[54.8182382167, 82.3800216667, "240"],
[54.8173681833, 82.3806125, "248C"],
[54.8181792333, 82.3832736333, "254A"],
[54.8095723, 82.3899326833, "383A"],
[54.81761125, 82.3835261667, "254D"],
[54.8028805167, 82.3962506667, "469"],
[54.8185789, 82.3845444, "254"],
[54.8163547167, 82.3812859833, "258"],
[54.7930282167, 82.40572125, "608"],
[54.821138, 82.38039485, "216D"],
[54.81606355, 82.3793317167, "267B"],
[54.81934515, 82.3785087833, "225"],
[54.8050155667, 82.3943832667, "443A"],
[54.81861015, 82.379036, "235A"],
[54.8121421833, 82.3842917833, "317"],
[54.7913696833, 82.4063793, "623"],
[54.8205651167, 82.3768472333, "201"],
[54.8205108, 82.37795785, "212"],
[54.8231057, 82.3725295333, "155A"],
[54.8046846167, 82.3939956333, "443B"],
[54.7964915667, 82.40187745, "559"],
[54.80485815, 82.39453205, "443C"],
[54.8060723667, 82.3939798167, "428"],
[54.8047227, 82.3946713167, "445"],
[54.8048381667, 82.3949814667, "448"],
[54.8045786833, 82.3947850833, "449"],
[54.7981357, 82.3900883333, "461B"],
[54.8099047, 82.39060605, "388"],
[54.8043014333, 82.3950148, "453"],
[54.8043075833, 82.3954701167, "456"],
[54.79168895, 82.4068591833, "626"],
[54.8021525833, 82.39678165, "481"],
[54.8034197833, 82.39575665, "463"],
[54.8032362167, 82.3959217833, "467"],
[54.80216475, 82.3974925167, "484"],
[54.8203596833, 82.3755115833, "191B"],
[54.7993380667, 82.3999904667, "522"],
[54.8085763833, 82.3912222, "391"],
[54.7981168833, 82.4004628, "533"],
[54.7969743333, 82.4013795333, "553"],
[54.7970796333, 82.4021227667, "554"],
[54.7943688833, 82.404582833, "590"],
[54.8073738833, 82.39222815, "419"],
[54.7955603667, 82.4027828667, "569"],
[54.8102608, 82.3842148333, "345A"],
[54.7958160167, 82.4031990833, "570"],
[54.7924329333, 82.4084768167, "630"],
[54.7956436833, 82.4033528333, "572"],
[54.7960458333, 82.4022678, "563"],
[54.8030297833, 82.3966600167, "472"],
[54.7963875, 82.4000470667, "547"],
[54.8052467, 82.39419005, "439"],
[54.8103165333, 82.38810555, "345C"],
[54.7987565833, 82.3998819167, "531A"],
[54.7982830833, 82.40023825, "531B"],
[54.79918855, 82.4000808833, "524"],
[54.7944693667, 82.4027557167, "577"],
[54.7950937833, 82.4031431333, "575"],
[54.7927918333, 82.4046828167, "603"],
[54.7947576333, 82.4034387833, "579"],
[54.8117228167, 82.38764085, "346B"],
[54.7911496667, 82.40664935, "629"],
[54.81588535, 82.3807131667, "267A"],
[54.7912028, 82.40724595, "634"],
[54.7908960167, 82.4074944, "638"],
[54.8108278167, 82.3873807333, "346A"],
[54.8109458667, 82.3868272333, "346"],
[54.8861902333, 82.4912457, "146"],
[54.8868429667, 82.4923818, "242"],
[54.8863162333, 82.4914635667, "150"],
[54.8866134167, 82.4930928167, "281"],
[54.8857069333, 82.49160115, "115"],
[54.88701045, 82.4928565167, "282"],
[54.8865745167, 82.4918085333, "196"],
[54.8847997667, 82.49160355, "1"],
[54.88530765, 82.49159645, "65"],
[54.8858858, 82.4924325333, "195"],
[54.88625505, 82.4922030167, "201"],
[54.8858815167, 82.49117815, "140"],
[54.8870972167, 82.4937585167, "370"],
[54.8871422667, 82.4932273333, "330"],
[54.8867199333, 82.4935654, "331"],
[54.88711285, 82.4670386167, "6"],
[54.8867336333, 82.4670516667, "3"],
[54.8867436833, 82.4669519, "1"],
[54.8869533833, 82.4669386667, "2"],
[54.8869398667, 82.46704125, "4"],
[54.887182, 82.46692505, "5"],
[54.9008030333, 82.4861118167, "2"],
[54.90075285, 82.4859038833, "1"],
[54.9009336167, 82.4865805833, "4"],
[54.9008800167, 82.4863431167, "3"],
[54.90100455, 82.4868142, "5"],
[54.9014235667, 82.4873154667, "7B"],
[54.9010728, 82.4870406333, "6"],
[54.9012685833, 82.4873578833, "7A"],
[54.9011401833, 82.4872876833, "7"],
[54.8158733667, 82.37666665, "18A"],
[54.8161566833, 82.3760580333, "16"],
[54.8161400333, 82.3766246833, "18B"],
[54.81564025, 82.3760005833, "20"],
[54.9147940667, 82.4781293167, "2"],
[54.91445275, 82.477954, "5"],
[54.91432165, 82.4780204333, "7"],
[54.9142254833, 82.4781627667, "9"],
[54.9142594833, 82.4783362167, "11"],
[54.9140805833, 82.4785308167, "11A"],
[54.9141151333, 82.47861905, "10A"],
[54.91436635, 82.4784698833, "10"],
[54.9144396667, 82.4784653667, "8"],
[54.9147089667, 82.47783895, "1"],
[54.9145894, 82.4778914333, "3"],
[54.9146597833, 82.4781811833, "4"],
[54.9145286, 82.4783673833, "6"],
[54.9030873667, 82.47210575, "3"],
[54.9032704833, 82.472054, "5"],
[54.9032275333, 82.4724681, "4"],
[54.9029155167, 82.4722868333, "1"],
[54.9029878333, 82.4725947167, "2"],
[54.9033794333, 82.4723403167, "6"],
[54.9033877, 82.4721768833, "8"],
[54.9026622333, 82.5342312833, "2/60"],
[54.8962902167, 82.5377237833, "3/157"],
[54.9056577833, 82.5300138, "24"],
[54.8978118667, 82.53526435, "1/157"],
[54.9036869333, 82.5324068, "46"],
[54.8976678167, 82.5356030833, "2/157"],
[54.9025187, 82.53438235, "3/60"],
[54.8981575333, 82.5358635, "1/158"],
[54.9027801667, 82.5340282833, "1/60"],
[54.8979776333, 82.536204, "2/158"],
[54.9023776667, 82.5345600167, "4/60"],
[54.8853151833, 82.4743354167, "6"],
[54.8839096667, 82.4747028, "17"],
[54.8826408833, 82.4741236667, "44"],
[54.8835314167, 82.4746655333, "21"],
[54.88308945, 82.4737775333, "28"],
[54.8814453833, 82.4749238167, "41"],
[54.8829200333, 82.4741641167, "40"],
[54.8804728833, 82.4739323833, "66"],
[54.8824228667, 82.47455335, "33"],
[54.8849254333, 82.4748141333, "9"],
[54.8815074833, 82.4735321333, "54A"],
[54.8829310333, 82.4736918167, "38"],
[54.8836627167, 82.47426195, "20"],
[54.8818192, 82.4745435833, "35"],
[54.8816592833, 82.4740403, "48"],
[54.8816905333, 82.4745296167, "37"],
[54.8835084, 82.47420785, "22"],
[54.8810922833, 82.4739643833, "58"],
[54.8814526, 82.4737812167, "52"],
[54.8813118333, 82.4739949167, "56"],
[54.88347125, 82.4749025167, "21A"],
[54.88493785, 82.4743158, "10"],
[54.88273915, 82.4748604167, "29A"],
[54.8837637667, 82.4746886167, "19"],
[54.8833199667, 82.47417425, "24"],
[54.8838467, 82.4742672333, "18"],
[54.8833191167, 82.4746548333, "23"],
[54.8845514833, 82.4742861, "14"],
[54.8853397, 82.4748736833, "5"],
[54.8847559333, 82.4748089167, "11"],
[54.8829521167, 82.47379525, "36"],
[54.88450605, 82.4747736667, "13"],
[54.8851099333, 82.4747525667, "7"],
[54.8847199, 82.4743100333, "12"],
[54.8831416, 82.4741727333, "26"],
[54.8808951333, 82.47394745, "60"],
[54.8808293167, 82.4744251333, "49"],
[54.8806857667, 82.4739440333, "62"],
[54.8815219, 82.4745206667, "39"],
[54.88054725, 82.47393465, "64"],
[54.8851369667, 82.4743293333, "8"],
[54.8829415167, 82.4735765833, "34"],
[54.8813163167, 82.4745132667, "45"],
[54.8825621, 82.4745672, "31"],
[54.882743, 82.4745888, "29"],
[54.8849588833, 82.4740735333, "10A"],
[54.8830033833, 82.47362085, "32"],
[54.8814134833, 82.4735401, "54"],
[54.8829174167, 82.4746101833, "27"],
[54.881329, 82.4749196167, "43"],
[54.8818477833, 82.4741495167, "46"],
[54.8806645833, 82.474444, "51"],
[54.8835542, 82.4740686833, "22A"],
[54.8815817333, 82.4735421833, "54B"],
[54.884082333, 82.4742836, "16"],
[54.8827733167, 82.4741382833, "42"],
[54.8831040167, 82.4746167333, "25"],
[54.88152945, 82.47402335, "50"],
[54.8810197, 82.4744641667, "47"],
[54.90035815, 82.4810595167, "6"],
[54.9004626167, 82.4814882, "5"],
[54.9004783333, 82.4807893167, "8"],
[54.90053035, 82.48110305, "10"],
[54.9001194333, 82.4813414167, "1"],
[54.9002854167, 82.4813794, "3"],
[54.9005929833, 82.4812279167, "12"],
[54.9005808667, 82.4813900667, "7"],
[54.90019795, 82.4810457333, "4"],
[54.9000177833, 82.4810738667, "2"],
[54.8970709833, 82.471412, "47"],
[54.8962267, 82.4699139833, "25"],
[54.8957546, 82.46976195, "14"],
[54.8960248333, 82.4695108167, "15"],
[54.8958360833, 82.4699171167, "16"],
[54.8960595667, 82.4695834167, "17"],
[54.8956411833, 82.46957925, "12"],
[54.8955700333, 82.46945925, "10"],
[54.8957725, 82.4690580833, "13"],
[54.8957180833, 82.4689838167, "11"],
[54.89593735, 82.4700870667, "18"],
[54.8960019667, 82.4702152333, "20"],
[54.8960897167, 82.4696367833, "21"],
[54.8960816667, 82.4703379833, "22"],
[54.8961728667, 82.4698312667, "23"],
[54.89611545, 82.4703987167, "24"],
[54.89616535, 82.4704619, "26"],
[54.8965143333, 82.4704345833, "31"],
[54.8965995, 82.4706005, "33"],
[54.8952596167, 82.46889415, "2"],
[54.8954856333, 82.4693051333, "8"],
[54.8953389167, 82.4690297167, "4"],
[54.8953875833, 82.469136, "6"],
[54.9194040167, 82.4783079, "10"],
[54.9197726333, 82.4782003, "12"],
[54.9194026167, 82.4796128167, "133"],
[54.9197761667, 82.47866625, "40"],
[54.9199951833, 82.4798155667, "148"],
[54.91981195, 82.47907645, "78"],
[54.9194262833, 82.4788171833, "59"],
[54.9196759333, 82.4798573833, "154"],
[54.9193148667, 82.48000435, "155"],
[54.9194418667, 82.479248, "95"],
[54.91985945, 82.47946575, "114"],
[54.8948282, 82.4632178833, "7"],
[54.8948541333, 82.4634539, "11"],
[54.8946653333, 82.46382725, "6A"],
[54.8942238167, 82.4629336667, "1A"],
[54.8942486167, 82.4635523667, "2"],
[54.8942641667, 82.4631693, "1"],
[54.8950186, 82.4640242, "8C"],
[54.8944589, 82.4631798333, "3"],
[54.8946294333, 82.4631902, "5"],
[54.89450815, 82.4635785333, "4"],
[54.8946479, 82.4635948, "6"],
[54.89498065, 82.4637099667, "8B"],
[54.8948863333, 82.4637035833, "8A"],
[54.89496985, 82.46325115, "9"],
[54.8947899667, 82.4637024167, "8"],
[54.89513905, 82.4640248667, "8D"],
[54.9428737167, 82.4654487167, "80"],
[54.9435976167, 82.4662367333, "85"],
[54.9406954, 82.4650713667, "60"],
[54.9443210167, 82.466494, "91"],
[54.9430113833, 82.4661685167, "79"],
[54.9423613, 82.4660200167, "73"],
[54.9217937167, 82.54130465, "1"],
[54.9214646833, 82.5409056667, "41"],
[54.9210630667, 82.5409307333, "86"],
[54.9211853667, 82.5410841, "66"],
[54.92096145, 82.5405598333, "83"],
[54.9206217333, 82.54086065, "133"],
[54.9216795, 82.5411416833, "21"],
[54.9213075167, 82.5412473167, "48"],
[54.9214208167, 82.54139905, "26"],
[54.9204421, 82.5405807833, "127"],
[54.8771340667, 82.4766456167, "17"],
[54.87582545, 82.4764970667, "2"],
[54.8772717167, 82.47651465, "19"],
[54.87616025, 82.47643495, "6"],
[54.87713215, 82.4761358333, "20"],
[54.8763702833, 82.4764765, "10"],
[54.8768617333, 82.4759845333, "18A"],
[54.87599415, 82.4764346167, "4"],
[54.8767086, 82.4760073, "18B"],
[54.8762125167, 82.4761083833, "8"],
[54.8771747, 82.4758428833, "22"],
[54.8774091, 82.4763950167, "21"],
[54.8764912333, 82.4760901, "18C"],
[54.8775394167, 82.47599195, "25"],
[54.8765312333, 82.47650495, "12"],
[54.8774804667, 82.47621635, "23"],
[54.8767157833, 82.4764832833, "14"],
[54.8776499, 82.4754748667, "26B"],
[54.8769073667, 82.4763486167, "16"],
[54.8774781667, 82.4755253167, "26A"],
[54.8769741333, 82.4767701, "15"],
[54.8761039, 82.4768351333, "3"],
[54.8767738333, 82.4768931333, "13"],
[54.8775332833, 82.4757816833, "27"],
[54.87661205, 82.4769204667, "11"],
[54.8773297333, 82.4756777167, "24"],
[54.8761442833, 82.47743145, "5B"],
[54.8761289667, 82.4772156167, "5A"],
[54.87642575, 82.47690055, "7"],
[54.87587225, 82.4768522667, "1"],
[54.8762655667, 82.4774301667, "5C"],
[54.8765258167, 82.4771421167, "9"],
[54.8775364167, 82.48049705, "9"],
[54.87721065, 82.48073405, "3"],
[54.8773645167, 82.48035315, "6"],
[54.8769231833, 82.4805237833, "2"],
[54.8776686, 82.4807239333, "7"],
[54.87711275, 82.4803929167, "4"],
[54.8774604167, 82.4807430667, "5"],
[54.87709625, 82.4808098667, "1"],
[54.8775519167, 82.48027995, "8"],
[54.8028734167, 82.5544968333, "64"],
[54.7908094, 82.55717225, "231"],
[54.8020794667, 82.5538755, "79"],
[54.8025875667, 82.5538326167, "73"],
[54.8788754667, 82.4246207833, "26"],
[54.8579076333, 82.423369, "257A"],
[54.8799908833, 82.4247353667, "14"],
[54.8576267333, 82.4217187, "257D"],
[54.8792310833, 82.4241302167, "21"],
[54.8560683833, 82.4248801833, "278"],
[54.8737989833, 82.42415875, "79"],
[54.8813433667, 82.42936065, "8/8"],
[54.8734102333, 82.4246495, "86"],
[54.8605645333, 82.42419905, "229"],
[54.8719786333, 82.4241769, "91"],
[54.8781270333, 82.4246374167, "34"],
[54.8720274833, 82.4248217833, "94"],
[54.8578687167, 82.4212873833, "257C"],
[54.87800375, 82.4263720167, "40"],
[54.8618965833, 82.4242119333, "213"],
[54.8801869167, 82.42773835, "1/8"],
[54.8779240167, 82.42463595, "36"],
[54.8743793333, 82.4246104667, "76"],
[54.8578661, 82.4218172, "257B"],
[54.8539269833, 82.4240546833, "293"],
[54.8767564, 82.4218264667, "49"],
[54.8598008833, 82.4242299667, "235"],
[54.8584386667, 82.42421145, "249"],
[54.8570034667, 82.4213275, "265"],
[54.8800888, 82.42631445, "10"],
[54.8771395667, 82.4240152, "43"],
[54.8781435167, 82.4240972, "33"],
[54.8767499333, 82.4247563, "52"],
[54.87567625, 82.42459055, "60"],
[54.8807013, 82.4246087167, "6"],
[54.8764337167, 82.42402455, "55"],
[54.8645742, 82.4242096833, "183"],
[54.88046835, 82.4241622833, "7"],
[54.8700695833, 82.4241415, "109"],
[54.87820565, 82.4227695333, "31"],
[54.86436995, 82.42472575, "184"],
[54.8712348833, 82.4199563167, "129"],
[54.8655708833, 82.4241920833, "163"],
[54.866108, 82.4247113333, "168"],
[54.85758825, 82.4248484667, "258"],
[54.8806747167, 82.4289119667, "3/8"],
[54.8808697333, 82.429829167, "5/8"],
[54.8805498667, 82.4315314333, "7/8"],
[54.8805142333, 82.4283195667, "8"],
[54.8642561, 82.4211131, "185B"],
[54.8642016333, 82.4241768167, "185C"],
[54.8584019167, 82.4247333, "254"],
[54.8579075, 82.4247216333, "256"],
[54.85733205, 82.4242334, "261"],
[54.8572177833, 82.4231895, "263"],
[54.8643650167, 82.4220877667, "185A"],
[54.89998625, 82.4831132833, "33"],
[54.9028015, 82.4824331833, "62A"],
[54.9027069833, 82.4824823167, "60A"],
[54.8999237833, 82.48395105, "28"],
[54.8998797667, 82.4835940667, "30"],
[54.9000587333, 82.4835154167, "32"],
[54.9016412667, 82.48230395, "51"],
[54.901574, 82.4827421167, "52"],
[54.90194355, 82.4826111667, "54"],
[54.90215485, 82.4824878833, "56"],
[54.9003890667, 82.48224575, "41"],
[54.9005753833, 82.4833095667, "42"],
[54.9004801833, 82.4824322, "43"],
[54.9007382, 82.48323555, "44"],
[54.9007203833, 82.4827551667, "45"],
[54.9008984833, 82.4831199, "46"],
[54.9010707, 82.4830293333, "48"],
[54.9010407167, 82.4825866833, "49"],
[54.90236485, 82.4823782167, "58"],
[54.9025425, 82.4818774167, "59"],
[54.9025757167, 82.4822757667, "60"],
[54.9029402833, 82.4816723667, "61"],
[54.90278895, 82.4821800333, "62"],
[54.9031374667, 82.4822319333, "64A"],
[54.9030315833, 82.4820359667, "64"],
[54.9032178667, 82.4819789333, "66"],
[54.9019434, 82.48286115, "54A"],
[54.8818104333, 82.4707039833, "12"],
[54.8814851833, 82.4704820167, "9"],
[54.8810768333, 82.4699034, "5B"],
[54.8818488, 82.4702216, "1"],
[54.8816215667, 82.47092875, "11"],
[54.8816941833, 82.4701273667, "2"],
[54.8811842333, 82.4704525667, "7"],
[54.8813522667, 82.47002245, "4"],
[54.88194605, 82.4707180167, "13"],
[54.8813308, 82.4704956333, "8"],
[54.88115305, 82.4702513333, "6"],
[54.8811936167, 82.4700739, "5A"],
[54.8815373167, 82.4700831, "3"],
[54.8816521333, 82.4705540833, "10"],
[54.8088981167, 82.36906915, "77"],
[54.8088042833, 82.3655253833, "80"],
[54.8066999167, 82.3689073333, "52"],
[54.8042113, 82.3710341667, "21"],
[54.8035833, 82.3699288833, "17"],
[54.8043107833, 82.3697591667, "23"],
[54.8108776667, 82.3698460833, "87B"],
[54.8045451333, 82.3697163333, "25"],
[54.8104246167, 82.365628, "94B"],
[54.8047750833, 82.3692679333, "30"],
[54.80400095, 82.3716803333, "19B"],
[54.8025388833, 82.3693096833, "2"],
[54.8032552333, 82.3718025, "19A"],
[54.8027435333, 82.3695240333, "4"],
[54.8105842, 82.3663406667, "94A"],
[54.8028778167, 82.3696653833, "6"],
[54.8095059667, 82.37026555, "81"],
[54.8055475667, 82.3691296833, "36"],
[54.8101165833, 82.3695157, "87A"],
[54.8055532333, 82.3695431833, "41"],
[54.8068988, 82.3688744333, "54"],
[54.8059911667, 82.3690365333, "44"],
[54.8074588333, 82.36921695, "59"],
[54.8075005667, 82.3687474667, "60"],
[54.80836585, 82.3685797833, "64"],
[54.8060896833, 82.3724944167, "67A"],
[54.8079139, 82.3722770833, "67B"],
[54.8089385167, 82.3721465167, "67C"],
[54.81012905, 82.3782445, "67D"],
[54.8110090333, 82.3680073333, "96"],
[54.8103251, 82.3687031333, "89"],
[54.8101581667, 82.36820355, "88"],
[54.8097519333, 82.36879765, "85"],
[54.8084821, 82.37132025, "69"],
[54.8818073167, 82.4679643, "6"],
[54.8823003833, 82.4676866167, "1"],
[54.8818464333, 82.4675593, "5"],
[54.8822481333, 82.4679646833, "2"],
[54.8817913833, 82.4677682167, "7"],
[54.8821612333, 82.4674131167, "3A"],
[54.8821403, 82.46766325, "3"],
[54.8821458833, 82.4679535, "4"],
[54.9077193667, 82.4708605833, "32"],
[54.9105951, 82.4793621667, "98A"],
[54.9066916333, 82.4685963, "19"],
[54.9104376833, 82.4794448167, "98"],
[54.9064596833, 82.4678557333, "11"],
[54.9103041333, 82.479528, "100"],
[54.9090584167, 82.477976, "83"],
[54.9088679, 82.4779112, "81B"],
[54.90751235, 82.4701317833, "26"],
[54.9085779167, 82.4748978833, "57B"],
[54.9077844167, 82.4710735, "34"],
[54.9088840833, 82.4747589333, "60"],
[54.9063916833, 82.4676261333, "9"],
[54.9091791167, 82.47510015, "64A"],
[54.9090063, 82.4778273167, "81"],
[54.9094076667, 82.4749288167, "66"],
[54.9104649333, 82.4812665333, "111"],
[54.9094658167, 82.47513735, "66A"],
[54.9106371667, 82.4806045833, "108"],
[54.9085164667, 82.47469955, "57A"],
[54.9065306333, 82.4680931667, "13B"],
[54.90744655, 82.46992735, "24"],
[54.90669875, 82.4675042833, "10"],
[54.9063321167, 82.467451, "7"],
[54.9068232667, 82.4690555333, "23"],
[54.9064476333, 82.4682054167, "13A"],
[54.90728695, 82.4687101167, "20A"],
[54.90564665, 82.4665080833, "1B"],
[54.9095425167, 82.4780996, "87"],
[54.9055099333, 82.4665785667, "1C"],
[54.9064278333, 82.4685453667, "17"],
[54.9087755667, 82.4730346, "48A"],
[54.9092946833, 82.4772395333, "77"],
[54.9089289833, 82.4729708, "48B"],
[54.9070766, 82.4680242167, "14A"],
[54.9099299333, 82.4794760167, "97"],
[54.9060196667, 82.4664193167, "3"],
[54.9093701833, 82.4764340333, "78"],
[54.9088882, 82.4759446333, "71"],
[54.9071022833, 82.4688659833, "20"],
[54.9087805333, 82.4732292667, "50A"],
[54.9101438333, 82.4802177167, "103"],
[54.9100409167, 82.4805634167, "105A"],
[54.9103943, 82.4797851, "102"],
[54.9097405333, 82.4787679167, "95"],
[54.9093126667, 82.4762224667, "76"],
[54.9076596, 82.4706490167, "30"],
[54.9090636667, 82.4764674667, "75"],
[54.9091701167, 82.47836235, "89"],
[54.9089457333, 82.4761631167, "73"],
[54.9085522833, 82.4736826, "52"],
[54.9092411833, 82.4760100667, "74"],
[54.9079714833, 82.4729381333, "45"],
[54.9080979833, 82.4733453333, "49"],
[54.9069515333, 82.4683180833, "16"],
[54.9066421833, 82.4673182, "8"],
[54.90937045, 82.47757155, "79"],
[54.9081895333, 82.47364565, "51"],
[54.9086237333, 82.4750583333, "59"],
[54.9091840167, 82.4757918333, "72"],
[54.9087522333, 82.47547835, "63"],
[54.90689515, 82.46927105, "25"],
[54.9078795, 82.4713550833, "36"],
[54.9056039, 82.4664057333, "1A"],
[54.9106886833, 82.4808305833, "110"],
[54.9059434167, 82.4661582833, "1"],
[54.90686465, 82.4680447333, "14"],
[54.9100754167, 82.4799441333, "101"],
[54.9096307667, 82.4784052167, "93"],
[54.9103163333, 82.4807391667, "107"],
[54.9099907833, 82.47967445, "99"],
[54.9102545333, 82.4804980667, "105"],
[54.9067854667, 82.46778495, "12"],
[54.9087875, 82.4761555333, "73A"],
[54.9088226667, 82.4757288667, "69"],
[54.90860015, 82.4738656333, "54"],
[54.9084004667, 82.4731332667, "48"],
[54.9086524, 82.4734778333, "52A"],
[54.9070271167, 82.4685905333, "18"],
[54.9075912333, 82.47002045, "26A"],
[54.9089373833, 82.4749522333, "62"],
[54.90542545, 82.4648276667, "2"],
[54.9075973667, 82.4703872167, "28"],
[54.9084245, 82.4757077667, "65"],
[54.90912645, 82.4755800667, "70"],
[54.90927015, 82.4751967833, "68A"],
[54.9094690167, 82.4778629667, "85"],
[54.90713625, 82.4682970167, "16A"],
[54.9084881667, 82.4734576333, "50"],
[54.9071228167, 82.4684523333, "18A"],
[54.9066047833, 82.4683209, "15"],
[54.9086888833, 82.4752875667, "61"],
[54.9092166833, 82.4785048333, "91"],
[54.90675295, 82.4688188167, "21"],
[54.9089505167, 82.4731089667, "50B"],
[54.9090581667, 82.4753575833, "68"],
[54.9086879167, 82.47334805, "50C"],
[54.91039185, 82.48101575, "109"],
[54.9091127833, 82.4786399833, "91A"],
[54.90897975, 82.4751060667, "64"],
[54.8717186833, 82.4615598167, "102"],
[54.8620697167, 82.4558799667, "224"],
[54.8767515, 82.4619986833, "42"],
[54.8664140333, 82.4578848167, "168"],
[54.8778354833, 82.46234395, "32"],
[54.8624631167, 82.456142, "216"],
[54.8639001667, 82.4568719667, "194"],
[54.8719572167, 82.4602589, "100"],
[54.87530725, 82.46140325, "60"],
[54.86265385, 82.4563095333, "214"],
[54.8736987167, 82.46078595, "80"],
[54.8899623167, 82.4632323, "57A"],
[54.8891142333, 82.4571846167, "4"],
[54.8896277, 82.4633464833, "59"],
[54.88913275, 82.4644998167, "60"],
[54.8891977, 82.46335, "1/52"],
[54.8902417, 82.4604661, "25A"],
[54.8892224667, 82.4630494333, "50"],
[54.8904468333, 82.4604248, "25"],
[54.8899309167, 82.45755835, "7"],
[54.8893669667, 82.4601698, "26"],
[54.8891862667, 82.4573128833, "4B"],
[54.8897543167, 82.4603741167, "27A"],
[54.8895259333, 82.4573211667, "4A"],
[54.8899523167, 82.4603841667, "27B"],
[54.8887959333, 82.4610821833, "34"],
[54.8901048833, 82.4603943833, "27C"],
[54.8891028833, 82.4650312333, "64"],
[54.88868315, 82.4633466833, "52B"],
[54.8896881, 82.4624856667, "43"],
[54.8899772333, 82.46296325, "53"],
[54.8893557167, 82.4604985333, "28"],
[54.8887644667, 82.46359225, "54A"],
[54.8887913667, 82.46338915, "52A"],
[54.8891714, 82.4635651833, "54B"],
[54.8898920167, 82.4582737, "13"],
[54.8891619167, 82.46382635, "56"],
[54.8902644667, 82.4602963, "23B"],
[54.8903580333, 82.4578762167, "9A"],
[54.8895457333, 82.4571203833, "2"],
[54.8899171667, 82.4577745667, "9"],
[54.8891239833, 82.4610409833, "32"],
[54.8886105167, 82.4627844833, "48A"],
[54.8897850667, 82.4601521667, "23"],
[54.8885782833, 82.4630716, "48B"],
[54.8895879667, 82.4639701, "65"],
[54.88875245, 82.4628892667, "48C"],
[54.8897637667, 82.46090555, "29"],
[54.8898831667, 82.4584686167, "15"],
[54.8900645833, 82.4630566333, "57"],
[54.8894477833, 82.4587900667, "20"],
[54.8898162, 82.4597956833, "21"],
[54.8903147667, 82.4585830833, "15A"],
[54.8899451, 82.4573311, "5"],
[54.8892625, 82.46226515, "42"],
[54.88959655, 82.4636994833, "63"],
[54.8888289, 82.4626433167, "46B"],
[54.8897502167, 82.4611882333, "31"],
[54.8890874833, 82.4653801667, "66"],
[54.8896453667, 82.4629410333, "51"],
[54.88871155, 82.4626789833, "46A"],
[54.8889027, 82.4648962833, "64A"],
[54.8888759167, 82.4633533167, "2/52"],
[54.8903299167, 82.4581553, "13A"],
[54.8890716, 82.4657335833, "68"],
[54.8894647167, 82.4584316167, "16"],
[54.8889404333, 82.4574026, "6B"],
[54.8896737667, 82.4626918667, "45"],
[54.8899074, 82.4580168, "11"],
[54.8898575333, 82.4588148833, "17"],
[54.8896982167, 82.46224375, "1/41-7/41"],
[54.8895164167, 82.4575203, "6"],
[54.8899765333, 82.4602187333, "23A"],
[54.8891143, 82.4647213833, "62"],
[54.8892440667, 82.46252665, "46"],
[54.88890735, 82.4607073833, "30A"],
[54.88930945, 82.4612971, "36"],
[54.8892202667, 82.4574350833, "6A"],
[54.8891678667, 82.4639653333, "58"],
[54.8898663667, 82.4589170833, "19"],
[54.88937355, 82.4599354833, "24"],
[54.8893259833, 82.4609626833, "32A"],
[54.8899845333, 82.4624851, "49"],
[54.8700170667, 82.4425962167, "35"],
[54.87002395, 82.4440538333, "45"],
[54.8703417167, 82.4408183833, "19"],
[54.8704475833, 82.44446245, "48"],
[54.8705703667, 82.44211805, "32"],
[54.8712876167, 82.4401329, "8"],
[54.8706072, 82.4431831333, "40"],
[54.88103245, 82.43996055, "74"],
[54.8810238833, 82.44054185, "144"],
[54.8819540833, 82.44341985, "444"],
[54.8810368167, 82.4414257833, "218"],
[54.8836569833, 82.4449454, "695"],
[54.8805499, 82.44146635, "219"],
[54.88153545, 82.4435217, "409"],
[54.8805337667, 82.4422020167, "277"],
[54.8810820333, 82.4423189667, "302"],
[54.8826985333, 82.4431283833, "503"],
[54.8825451667, 82.4439081167, "533"],
[54.8834376, 82.4454858167, "694"],
[54.8806721167, 82.44412345, "397"],
[54.81387095, 82.45409265, "1"],
[54.821195, 82.4616223833, "104"],
[54.8211624833, 82.4682833, "181"],
[54.8178846167, 82.4588240333, "65"],
[54.8149536667, 82.4553629333, "15"],
[54.8197732667, 82.4671436, "167"],
[54.8161526333, 82.4563465, "35"],
[54.8209648833, 82.4674674, "178"],
[54.820487, 82.4606511167, "86"],
[54.9711954833, 82.3673120333, "66"],
[54.8927382667, 82.4630076, "2A"],
[54.8930191833, 82.4631100333, "1"],
[54.89302745, 82.4629626333, "1A"],
[54.8927669333, 82.46308965, "2"],
[54.8929038667, 82.46322235, "5"],
[54.8926603333, 82.4633015, "3A"],
[54.89273305, 82.4631913833, "3"],
[54.8928261167, 82.4632172333, "4"],
[54.8863257333, 82.3892431333, "29"],
[54.8828649833, 82.3942711333, "76"],
[54.88740485, 82.3880108167, "3"],
[54.8816477833, 82.39495895, "85"],
[54.9193026667, 82.46865615, "27"],
[54.9191047667, 82.4689871, "21"],
[54.9190031667, 82.4685222, "29"],
[54.9191244667, 82.4666619167, "55"],
[54.9187559333, 82.4673880833, "43"],
[54.9191856, 82.4667804333, "49"],
[54.9183846667, 82.4653317833, "75"],
[54.9186045833, 82.46662185, "59"],
[54.9191840167, 82.4678865167, "35"],
[54.9191584333, 82.4662006333, "61"],
[54.9188624, 82.4676419833, "39"],
[54.9184419667, 82.4657698, "69"],
[54.9178364167, 82.4627168667, "111"],
[54.9185242667, 82.4661814167, "63"],
[54.9191998, 82.4694479333, "17"],
[54.9190388167, 82.4654450833, "71"],
[54.91796485, 82.4632720833, "103"],
[54.91880005, 82.4653678333, "73"],
[54.9182357167, 82.4645811, "93"],
[54.9177229333, 82.4619539, "119"],
[54.91802955, 82.4624559167, "115"],
[54.9176650833, 82.4616779667, "123"],
[54.91870075, 82.4670770833, "45"],
[54.9176143667, 82.4613274, "125"],
[54.9189086667, 82.468155, "33"],
[54.9174097167, 82.4613318833, "127"],
[54.9190924, 82.4675234333, "41"],
[54.8068523167, 82.3939250833, "5"],
[54.8144720167, 82.4032648333, "122"],
[54.8070121667, 82.3941206333, "7"],
[54.8135841833, 82.40160315, "114"],
[54.8071723, 82.39433025, "9"],
[54.8073319667, 82.3945375, "13"],
[54.8088248333, 82.39658935, "35"],
[54.8150867, 82.4041908167, "138"],
[54.8087098667, 82.39797025, "45"],
[54.8153430833, 82.4043867333, "140"],
[54.8113713333, 82.3997835833, "77"],
[54.8128633667, 82.4026050333, "103"],
[54.8153182333, 82.404702, "142"],
[54.8136947667, 82.4026962667, "113"],
[54.8146717833, 82.4042277167, "133"],
[54.8132897167, 82.40224345, "105"],
[54.87318525, 82.5752061, "783"],
[54.87086625, 82.5605686167, "3/668"],
[54.8736095333, 82.5759500667, "791"],
[54.8846973333, 82.5128454333, "105"],
[54.882909, 82.5284399, "295"],
[54.8854251167, 82.50715345, "42"],
[54.8730277, 82.5735052333, "768"],
[54.8852305667, 82.5138063667, "116"],
[54.8765950833, 82.5441586167, "457"],
[54.8854819167, 82.51593135, "130"],
[54.8793962333, 82.5400538, "398"],
[54.8856814667, 82.5176310333, "146"],
[54.8850541667, 82.5122725, "94"],
[54.8859048, 82.5196622667, "158"],
[54.8839926333, 82.5070946667, "44"],
[54.8828246833, 82.5299873833, "300"],
[54.8835640333, 82.5073463, "47"],
[54.8812550167, 82.53308795, "338"],
[54.87624165, 82.5468433, "472"],
[54.8735672333, 82.5726554167, "2/766"],
[54.8756854833, 82.5468615167, "483"],
[54.8855889333, 82.5069699, "1/42"],
[54.8764352833, 82.55027325, "508"],
[54.88626155, 82.5222170833, "2/182"],
[54.8739916667, 82.5532237833, "537"],
[54.8790302167, 82.5397931667, "396"],
[54.8750138, 82.5530649833, "542"],
[54.8839209333, 82.5106114167, "79"],
[54.8790556833, 82.5364847667, "371"],
[54.8804106667, 82.5347674167, "348"],
[54.8843208, 82.50806425, "50"],
[54.8835448667, 82.50621025, "37"],
[54.8789683667, 82.5407611667, "400"],
[54.8819428333, 82.5302822333, "307"],
[54.8838573833, 82.5041196833, "26"],
[54.8728271833, 82.5730276667, "1/766"],
[54.8862517333, 82.5218569167, "1/182"],
[54.88592065, 82.52030825, "170"],
[54.8804488333, 82.5336723833, "345"],
[54.8724145667, 82.5722238833, "756"],
[54.8710689167, 82.5600702167, "2/668"],
[54.8749418667, 82.5762505333, "808"],
[54.88330185, 82.5037989167, "25"],
[54.8742985667, 82.5709469667, "766"],
[54.8855461833, 82.5169524167, "138"],
[54.8840771833, 82.5086316, "57"],
[54.8799641333, 82.5345286833, "351"],
[54.8747767833, 82.5703700833, "4/766"],
[54.8712547, 82.5595212, "1/668"],
[54.8852620333, 82.5203346333, "167"],
[54.87846535, 82.5402971, "407"],
[54.87451705, 82.5722616833, "3/766"],
[54.8865716667, 82.5064284333, "2/42"],
[54.8699697833, 82.5701625667, "725"],
[54.8850022833, 82.5119347333, "92"],
[54.9141589833, 82.4676254, "19"],
[54.9155973833, 82.46772575, "11/2"],
[54.91552955, 82.4660865, "36/2"],
[54.9156190333, 82.4673462667, "9/2"],
[54.9154039167, 82.4660434167, "35/2"],
[54.9155738333, 82.4664463167, "5/2"],
[54.91535915, 82.4658985167, "34/2"],
[54.9155678833, 82.4667106333, "6/2"],
[54.91544365, 82.4658299, "33/2"],
[54.9160503333, 82.4675822, "21/2"],
[54.9156064333, 82.4657751333, "32/2"],
[54.9147495167, 82.4662775167, "5"],
[54.9157566167, 82.46569785, "31/2"],
[54.9154667667, 82.4679029167, "12/2"],
[54.91585185, 82.4657343333, "30/2"],
[54.9152016333, 82.4653091167, "1"],
[54.9153522167, 82.4663997833, "4"],
[54.9156452333, 82.4675400833, "10/2"],
[54.9153521167, 82.4665981833, "4A"],
[54.91558475, 82.4671245833, "8/2"],
[54.9153486333, 82.4667996333, "6"],
[54.9155721333, 82.4669092, "7/2"],
[54.9152996667, 82.4669875833, "6A"],
[54.9150243, 82.46636625, "5A"],
[54.9162041333, 82.4675381333, "22/2"],
[54.9162005, 82.4673120333, "23/2"],
[54.9161440167, 82.4671061, "24/2"],
[54.9160962667, 82.4669004667, "25/2"],
[54.9160486333, 82.4666893333, "26/2"],
[54.9159963833, 82.46648905, "27/2"],
[54.91591785, 82.4662933333, "28/2"],
[54.9157758667, 82.4662000667, "38/2"],
[54.9157248667, 82.4659447167, "37/2"],
[54.9158606, 82.46592755, "29/2"],
[54.9159540833, 82.4673968833, "20/2"],
[54.91578295, 82.4674348167, "17/2"],
[54.91584205, 82.4677180167, "18/2"],
[54.9156962333, 82.4664396833, "13/2"],
[54.915699, 82.4667043333, "14/2"],
[54.9157030167, 82.4669139, "15/2"],
[54.9157118833, 82.4671016, "16/2"],
[54.9158802833, 82.4671848, "19/2"],
[54.9146419333, 82.4678385333, "16"],
[54.9149667, 82.46605435, "3"],
[54.9150279333, 82.4667922833, "7"],
[54.9141704333, 82.4678512833, "21"],
[54.9142653, 82.4673118833, "15"],
[54.91450075, 82.4674330833, "13"],
[54.9147242667, 82.46734925, "11"],
[54.9148913167, 82.4671297667, "9"],
[54.9151929833, 82.4672369167, "8"],
[54.9144812833, 82.4679524833, "18"],
[54.9149502167, 82.4675873667, "12"],
[54.9147979333, 82.4677301167, "14"],
[54.9140953833, 82.4682407667, "22"],
[54.9143135333, 82.4679806667, "20"],
[54.9139027667, 82.4673990667, "17"],
[54.91508455, 82.46743825, "10"],
[54.8207364833, 82.3925286333, "110"],
[54.8140913167, 82.3867786167, "31"],
[54.82388165, 82.3961648833, "164"],
[54.8149241833, 82.3869723167, "38"],
[54.8341317167, 82.4133935833, "364"],
[54.8244762167, 82.39859475, "186"],
[54.82108675, 82.3928284333, "112"],
[54.8257318, 82.4028302167, "236"],
[54.8213587333, 82.3930749333, "114"],
[54.8245402667, 82.3979335833, "184"],
[54.8216469333, 82.3939728667, "129"],
[54.8287610333, 82.4083265833, "302"],
[54.82049075, 82.3882675333, "92"],
[54.8209210167, 82.3876718333, "90B"],
[54.8243807167, 82.4009181, "207"],
[54.8210754833, 82.3869467167, "90A"],
[54.8142259167, 82.3862871667, "26"],
[54.8142241, 82.3891889667, "43"],
[54.8355967167, 82.4144058667, "382"],
[54.8263508333, 82.4048937333, "251"],
[54.8237985833, 82.3972016667, "173"],
[54.82187925, 82.3941376333, "137"],
[54.8159891667, 82.3862058833, "42"],
[54.8233059333, 82.3950369833, "156"],
[54.8224871333, 82.3939314167, "148"],
[54.8194135833, 82.3914179833, "100"],
[54.8149244, 82.38763835, "41"],
[54.8192395667, 82.3919598167, "103"],
[54.8202387167, 82.3879586, "90D"],
[54.81610515, 82.3888637333, "59"],
[54.8282481667, 82.4077297, "290"],
[54.81714775, 82.3892465833, "68"],
[54.8196078, 82.3887699667, "90"],
[54.817284, 82.39001715, "77"],
[54.81837465, 82.39045065, "86"],
[54.8277749, 82.4071191667, "272"],
[54.8265916333, 82.4056707167, "251A"],
[54.8128841167, 82.3855143833, "11"],
[54.8291297, 82.4098336167, "313"],
[54.8329969667, 82.4126325333, "358"],
[54.8322266, 82.4129321167, "347"],
[54.8348266833, 82.4139054, "372"],
[54.9099726167, 82.4757886667, "71"],
[54.9101903333, 82.4760631833, "73"],
[54.9152217167, 82.47371395, "131"],
[54.9059390167, 82.47854405, "32"],
[54.9097995667, 82.4753924833, "71B"],
[54.9044269833, 82.4792423333, "12"],
[54.9084252667, 82.4764496833, "49"],
[54.9086711167, 82.4772269833, "52"],
[54.9116987, 82.4759278667, "92"],
[54.9098638167, 82.47581795, "69"],
[54.9117964333, 82.4757621167, "94"],
[54.90989485, 82.47559865, "71A"],
[54.9073590833, 82.4778494167, "40A"],
[54.91330765, 82.47552755, "108"],
[54.9057401833, 82.4781938167, "25"],
[54.911296, 82.4748848167, "89"],
[54.9121108667, 82.4758530667, "98A"],
[54.9043787833, 82.4787889167, "13"],
[54.9083076667, 82.4766785667, "47A"],
[54.9036909333, 82.4791402667, "3"],
[54.91220345, 82.4755294, "100"],
[54.9053728833, 82.4783509333, "1/23"],
[54.90519915, 82.4784179, "21"],
[54.9052690667, 82.4783896667, "21A"],
[54.9114245, 82.4759148333, "88"],
[54.9081505833, 82.4774655, "46"],
[54.9142982833, 82.4745833, "120"],
[54.9131166, 82.4751412333, "106"],
[54.9083510667, 82.47694365, "47"],
[54.9065192667, 82.4778253667, "31"],
[54.9083240333, 82.47739375, "48"],
[54.9149526833, 82.4742867833, "126"],
[54.9103091667, 82.476032, "75"],
[54.9118749833, 82.4749764833, "101A"],
[54.9042161667, 82.4788623333, "11"],
[54.9129278167, 82.4752157333, "104"],
[54.9121256667, 82.4751926333, "103"],
[54.9112547, 82.4755432667, "85"],
[54.9142550667, 82.4741810667, "121"],
[54.9106238667, 82.4759059667, "77A"],
[54.9104479, 82.4759570167, "77"],
[54.9114070667, 82.4754850833, "87"],
[54.9113298833, 82.47516835, "87A"],
[54.9148737833, 82.4738503833, "127"],
[54.9112868667, 82.4759815833, "86"],
[54.9111339667, 82.4760538, "82"],
[54.91156375, 82.4758556833, "90"],
[54.9151142, 82.4742192667, "128"],
[54.9151403167, 82.4737436, "129"],
[54.915375, 82.4740628167, "130"],
[54.9144834167, 82.4745128333, "122"],
[54.9144913, 82.4737651167, "123A"],
[54.9144983167, 82.4740186167, "123"],
[54.9146270167, 82.4744201833, "124"],
[54.9126748, 82.4749461833, "105"],
[54.9128134833, 82.4748703333, "107"],
[54.9129492333, 82.4747718167, "109"],
[54.9131005833, 82.4746998, "111"],
[54.9132571833, 82.4746269833, "113"],
[54.9135018833, 82.4749717, "114"],
[54.91340395, 82.4745515, "115"],
[54.9136698, 82.4748826167, "116"],
[54.91356065, 82.4744797, "117"],
[54.91379245, 82.4748357, "118"],
[54.9136715833, 82.4744300167, "119"],
[54.9085906833, 82.4768593, "53"],
[54.9089448167, 82.47752235, "54A"],
[54.9088353, 82.4771584333, "54"],
[54.9087287167, 82.4767663333, "55"],
[54.9090036667, 82.4770825167, "56"],
[54.9065108833, 82.4773228833, "33"],
[54.90671225, 82.4781606833, "34"],
[54.90673975, 82.4777032, "35"],
[54.9068835, 82.4780653833, "36"],
[54.9067380833, 82.4772301167, "37"],
[54.9070569167, 82.47798485, "38"],
[54.9070025333, 82.4775753333, "39"],
[54.90721945, 82.47790165, "40"],
[54.9072522667, 82.4774842833, "41"],
[54.9073576167, 82.47744775, "43"],
[54.9055054167, 82.4782415167, "23"],
[54.9146826833, 82.4739228, "125"],
[54.9048823167, 82.4785375333, "17"],
[54.9120084333, 82.4756561667, "98"],
[54.9086973167, 82.4775292833, "52A"],
[54.90495545, 82.4780925667, "19A"],
[54.9115964667, 82.4754098667, "91"],
[54.9117456333, 82.4753338667, "93"],
[54.9047131167, 82.47861435, "15"],
[54.9166350333, 82.47304345, "141"],
[54.9119624833, 82.4752623, "101"],
[54.9039384833, 82.4785719, "9A"],
[54.9040451, 82.4789520667, "9"],
[54.9159567333, 82.4733394833, "133"],
[54.9133416833, 82.4750525833, "112"],
[54.9164713167, 82.4731105667, "139"],
[54.9162964833, 82.4731911, "137"],
[54.91611805, 82.4732665833, "135"],
[54.9050444167, 82.4785102333, "19"],
[54.9084974833, 82.47730975, "50"],
[54.9168131667, 82.4729816333, "143"],
[54.9088890667, 82.47665875, "51"],
[54.9169769833, 82.47291525, "145"],
[54.91109855, 82.4756779833, "83"],
[54.9036883833, 82.47891485, "5"],
[54.9038746333, 82.4790332667, "7"],
[54.9098547333, 82.4762237333, "67"],
[54.9134471167, 82.47558925, "110"],
[54.9091846167, 82.4769739333, "58"],
[54.9041253333, 82.47834505, "67"],
[54.9031156667, 82.47324245, "30"],
[54.9039179333, 82.4771832667, "57"],
[54.9027583833, 82.4732321833, "31"],
[54.9039296333, 82.4759913167, "1/48-5/48"],
[54.9031900333, 82.4735082833, "32"],
[54.9034018667, 82.4743276167, "36"],
[54.9023766833, 82.47196845, "7"],
[54.9032458833, 82.47560575, "49A"],
[54.9020863667, 82.4722218833, "9"],
[54.9043371833, 82.4768388333, "56B"],
[54.902459, 82.47222945, "15"],
[54.9037351, 82.47533715, "44"],
[54.9034826333, 82.4756647333, "51"],
[54.9036591, 82.47507465, "42"],
[54.90418945, 82.4769539167, "56"],
[54.9032979333, 82.4750164, "45"],
[54.9034232167, 82.47544545, "49"],
[54.9033578, 82.4752311833, "47"],
[54.9038201667, 82.4756474167, "46"],
[54.9022973167, 82.4729606, "25"],
[54.90414875, 82.4768183, "52"],
[54.90349885, 82.4745345833, "38"],
[54.9026894, 82.4730117167, "29"],
[54.9021493667, 82.47246275, "17"],
[54.9026062167, 82.47272955, "23"],
[54.9025311667, 82.4725057, "21"],
[54.9030380667, 82.47297935, "28"],
[54.9024547167, 82.4734671, "33"],
[54.9025374333, 82.4713386333, "2"],
[54.9032365, 82.4747976667, "43"],
[54.903545, 82.4758786333, "53"],
[54.9036348667, 82.47615225, "55"],
[54.9040838167, 82.4777189667, "61"],
[54.9044308, 82.4778047833, "62A"],
[54.9045770833, 82.4776408667, "62"],
[54.9041435833, 82.4779421667, "63"],
[54.9045395167, 82.4780827833, "64"],
[54.9042280667, 82.4782127, "65"],
[54.9046025833, 82.4783325333, "66"],
[54.9027241, 82.4719824833, "6"],
[54.9031429167, 82.4744526833, "41"],
[54.90234395, 82.4730909833, "27"],
[54.9035807667, 82.474814, "40"],
[54.9024965667, 82.4735884667, "35"],
[54.9028375333, 82.4735153, "37"],
[54.90263765, 82.4716923333, "4"],
[54.9021975, 82.47257235, "19"],
[54.9043748667, 82.4775318, "60"],
[54.90399325, 82.4774612167, "59"],
[54.9042882333, 82.4772585333, "58"],
[54.8844172167, 82.4672121, "84"],
[54.88526725, 82.4677498167, "89"],
[54.88475025, 82.4713889167, "129A"],
[54.8850106, 82.4704196167, "119B"],
[54.8848693167, 82.4653303833, "67A"],
[54.8849946167, 82.47052095, "119A"],
[54.8853588667, 82.4594981667, "21A"],
[54.8840973667, 82.4733293833, "140"],
[54.88468505, 82.4712750833, "127B"],
[54.8848600667, 82.47296205, "141"],
[54.8846001333, 82.4600292833, "26A"],
[54.8836016167, 82.4733639667, "142"],
[54.8834011333, 82.4735009333, "144A"],
[54.8836620833, 82.4735234, "144"],
[54.8836292333, 82.4677762333, "92A"],
[54.8848011, 82.4732428833, "145"],
[54.8848537, 82.4655050667, "67B"],
[54.8840610333, 82.4737371333, "146"],
[54.884338, 82.4684939, "106"],
[54.8844335167, 82.4733986333, "147"],
[54.88444615, 82.4731180167, "1/143"],
[54.8840384, 82.4739760167, "148"],
[54.8846361, 82.4730721, "2/143"],
[54.8847583667, 82.4735201333, "149"],
[54.8847493833, 82.4736688167, "151"],
[54.8846399333, 82.4737421667, "153A"],
[54.8844193833, 82.4737101333, "153"],
[54.8844016, 82.4739577167, "155"],
[54.8846051, 82.4703118167, "117"],
[54.8842630167, 82.4702309167, "118"],
[54.8845899833, 82.4706008833, "119"],
[54.8839889, 82.4702975, "120"],
[54.8845767833, 82.4708850333, "121"],
[54.8848939667, 82.471153, "125"],
[54.8845648, 82.4711997833, "127A"],
[54.8845397333, 82.4714559833, "129"],
[54.8845394, 82.4715708167, "131"],
[54.88370185, 82.4681742833, "100A"],
[54.8839465, 82.4681139833, "100"],
[54.8839286333, 82.4682708, "102"],
[54.8847414667, 82.4683697167, "101"],
[54.8843311333, 82.4683495167, "104"],
[54.8850005167, 82.468632, "105"],
[54.8847132167, 82.4687043167, "107"],
[54.88432375, 82.4686693, "108A"],
[54.8841027333, 82.4686521333, "108B"],
[54.8837668333, 82.4686217667, "108C"],
[54.8843156167, 82.4690232667, "110"],
[54.8844019333, 82.4676185833, "88"],
[54.8839683, 82.4676575, "90"],
[54.8839636333, 82.4677862833, "92"],
[54.8847523333, 82.4678389667, "93"],
[54.8843878667, 82.4678844833, "94"],
[54.8843912, 82.46807835, "96"],
[54.88488445, 82.4681411333, "97A"],
[54.8847461167, 82.4681295167, "97"],
[54.8850594333, 82.46849965, "103"],
[54.88521615, 82.46866015, "105A"],
[54.8852093833, 82.4680692333, "95B"],
[54.8844562, 82.4666664667, "82"],
[54.8844693167, 82.4664959833, "80"],
[54.8850079167, 82.4663639833, "77"],
[54.8850347667, 82.4662661667, "75A"],
[54.8845094, 82.46511225, "70"],
[54.8848360833, 82.46580235, "71"],
[54.8845048333, 82.4652718333, "72"],
[54.88484705, 82.4659848667, "73"],
[54.8846077667, 82.4632926667, "56"],
[54.8849583, 82.4636067667, "57"],
[54.8849358667, 82.46389605, "59"],
[54.8846143167, 82.4635059, "60"],
[54.8849265833, 82.4640693333, "61"],
[54.88458485, 82.4638039167, "62"],
[54.8846887167, 82.4620028833, "40"],
[54.8846763667, 82.4622161, "42"],
[54.88439555, 82.46253885, "50A"],
[54.8843140667, 82.4625245333, "50B"],
[54.8846659833, 82.4626401167, "50"],
[54.8843395, 82.4756649667, "165"],
[54.8843288167, 82.4758768167, "167"],
[54.8847458167, 82.4759882, "169"],
[54.8839907333, 82.4754077667, "154"],
[54.8832283833, 82.4761336167, "158A"],
[54.8834749667, 82.4760305, "158"],
[54.8839257333, 82.4761204333, "160"],
[54.8839105, 82.4763266167, "162"],
[54.8839068667, 82.4765393833, "164"],
[54.8839006667, 82.4766556333, "166A"],
[54.8838300333, 82.4766482833, "166B"],
[54.8837648667, 82.4766430667, "166C"],
[54.88370985, 82.4766495333, "166D"],
[54.88450305, 82.4759053833, "167A"],
[54.8843063833, 82.47627465, "173"],
[54.88481905, 82.4593686833, "20"],
[54.8848109, 82.4595419, "22"],
[54.8847686333, 82.4602303333, "28"],
[54.8847849, 82.4600010333, "26"],
[54.8847695, 82.4604640833, "30"],
[54.8847524167, 82.4606697667, "32A"],
[54.8846032167, 82.4607054667, "32"],
[54.8847437, 82.4609159, "34"],
[54.8847367167, 82.4610480333, "36"],
[54.8846226, 82.4597085, "24A"],
[54.88480055, 82.4597682833, "24"],
[54.8849988, 82.45680165, "4"],
[54.88498305, 82.4570515667, "6"],
[54.8852893167, 82.45737525, "9A"],
[54.8856279667, 82.4573165333, "9"],
[54.8852346167, 82.4583441167, "17"],
[54.8846999, 82.46184155, "38"],
[54.8842668333, 82.4699965667, "116"],
[54.8849434, 82.4633167, "55"],
[54.8849201333, 82.4582107833, "14"],
[54.8841963333, 82.4680842833, "98"],
[54.8850626333, 82.4680435333, "95A"],
[54.8849265167, 82.4579232, "12"],
[54.8849416333, 82.4576479667, "10"],
[54.88464885, 82.4628154667, "52"],
[54.88495495, 82.4630154, "53"],
[54.8841566, 82.46306945, "54C"],
[54.8843828833, 82.4631118167, "54B"],
[54.8846277833, 82.4630559167, "54A"],
[54.8852737333, 82.4576375667, "11"],
[54.8849684, 82.4572897333, "8"],
[54.8842156, 82.4664696, "80A"],
[54.8852629167, 82.4609307833, "31A"],
[54.88407215, 82.4664618, "80B"],
[54.8853292833, 82.4658178167, "69D"],
[54.8845638833, 82.4761256667, "171A"],
[54.8843256167, 82.4761031333, "171"],
[54.88461985, 82.4700835333, "115"],
[54.8852249667, 82.4591643, "19"],
[54.8850024667, 82.4655843667, "69A"],
[54.8853347667, 82.4565859833, "3"],
[54.8849291167, 82.4710324667, "123"],
[54.8850487333, 82.46776055, "91"],
[54.88518005, 82.4657751833, "69B"],
[54.8847597, 82.4703240833, "117A"],
[54.8838148667, 82.4733438, "140A"],
[54.8852627, 82.4581414167, "15"],
[54.8852686333, 82.4578723833, "13"],
[54.8843833333, 82.4628765333, "52A"],
[54.8846312667, 82.47258135, "135A"],
[54.8841268, 82.4727441333, "134"],
[54.8841223833, 82.4729087, "136"],
[54.8844595167, 82.4725233833, "135"],
[54.8844608, 82.4728356, "139"],
[54.88411085, 82.4730945167, "138"],
[54.8844061, 82.4674269333, "86"],
[54.8846697, 82.4623996833, "44"],
[54.8843516833, 82.4624326667, "46"],
[54.8845218833, 82.4609426833, "34A"],
[54.8845623833, 82.4649360333, "68"],
[54.8852556667, 82.46580475, "69C"],
[54.8853163833, 82.4638318667, "57A"],
[54.8841402833, 82.4725588333, "132"],
[54.8845058, 82.46627115, "78"],
[54.88520865, 82.4594427, "21"],
[54.88518675, 82.4597238, "23"],
[54.88516405, 82.4602253833, "27A"],
[54.8851860333, 82.4600092, "25"],
[54.8851601667, 82.4603894167, "27B"],
[54.8851518333, 82.4606064167, "29"],
[54.8851348833, 82.4608605667, "31"],
[54.8850809, 82.4610533333, "33"],
[54.8856552, 82.4571406667, "7A"],
[54.8853045167, 82.4571108167, "7"],
[54.88540295, 82.4658220667, "69E"],
[54.8853268167, 82.459619, "23A"],
[54.8836866, 82.4760956667, "160A"],
[54.8847632333, 82.4673442, "83"],
[54.8847711333, 82.4675412167, "85"],
[54.8848386167, 82.4661800667, "75"],
[54.8845198, 82.4660549333, "76"],
[54.8848257667, 82.46637395, "79"],
[54.88481345, 82.4665570333, "81"],
[54.8850432333, 82.4640734333, "61A"],
[54.8854814333, 82.46382035, "57B"],
[54.8853202, 82.45681275, "5"],
[54.88467615, 82.4756712, "165A"],
[54.8843590833, 82.4753791667, "163"],
[54.8854775, 82.4568292667, "5A"],
[54.8846230833, 82.4699498, "113"],
[54.8840125667, 82.47500995, "150"],
[54.8840018667, 82.4752078667, "152"],
[54.8846837667, 82.4753169, "163A"],
[54.8843619333, 82.4750396667, "161"],
[54.8840304667, 82.4794188333, "2A"],
[54.8807723833, 82.4785762167, "38"],
[54.8832733667, 82.4785025167, "14"],
[54.8805087833, 82.4795802, "39"],
[54.8825106167, 82.4792898667, "22"],
[54.8807048667, 82.4788063333, "40"],
[54.88040735, 82.47993645, "41"],
[54.8802707, 82.4795716333, "43"],
[54.8806401833, 82.4791473833, "46"],
[54.8805187667, 82.4791179667, "48"],
[54.8803874167, 82.47910085, "52A"],
[54.8832278833, 82.4793638667, "16"],
[54.8830907167, 82.4793476833, "18"],
[54.8821391833, 82.4796965667, "27"],
[54.8822759, 82.4797246333, "25"],
[54.88156645, 82.4792199667, "26"],
[54.88154905, 82.4796941667, "29"],
[54.8814046333, 82.4791842167, "28"],
[54.8841534, 82.4798770333, "1"],
[54.88124075, 82.47917795, "30"],
[54.8811993833, 82.4787023, "32"],
[54.8809580167, 82.4791391833, "34"],
[54.8809750667, 82.4788466833, "34A"],
[54.8835383667, 82.4798388, "9"],
[54.8831311167, 82.4801495667, "15"],
[54.88322745, 82.47980485, "13"],
[54.8806638833, 82.4795858667, "37"],
[54.88084555, 82.4786213833, "36"],
[54.88399585, 82.4798779833, "3"],
[54.8839041667, 82.4794138833, "2"],
[54.8837673333, 82.4794031833, "4"],
[54.8837132667, 82.4798593833, "7"],
[54.8808555833, 82.47961625, "35"],
[54.8835850167, 82.47938365, "8"],
[54.8838495167, 82.4798612, "5"],
[54.8837031833, 82.4801284167, "7A"],
[54.8836938167, 82.47892395, "6"],
[54.8833948833, 82.4788199167, "12"],
[54.8832576167, 82.4787911, "14A"],
[54.8834012333, 82.4798226333, "11"],
[54.8834290167, 82.4793790167, "10"],
[54.9152153667, 82.5551235833, "3/5"],
[54.91650135, 82.5636650667, "82"],
[54.9161045333, 82.5591854333, "41"],
[54.9154124667, 82.5548626, "2/5"],
[54.9166862333, 82.55784235, "32"],
[54.91602365, 82.5560715, "21"],
[54.91628925, 82.5653876833, "94"],
[54.9160243833, 82.55493095, "1/5"],
[54.9158285, 82.5660481167, "109"],
[54.91440645, 82.5544777167, "9"],
[54.9154713667, 82.56556335, "105"],
[54.9123841333, 82.5769109, "1/239"],
[54.9138841833, 82.5671444, "127"],
[54.916035, 82.5569371167, "25"],
[54.91497065, 82.5671545333, "1/114"],
[54.9146378167, 82.5673035, "2/114"],
[54.9176808667, 82.5727210167, "192"],
[54.91296825, 82.57312245, "1/192"],
[54.9165331, 82.56259155, "70"],
[54.9128700167, 82.5676242167, "135"],
[54.9127302333, 82.5677905167, "137"],
[54.9138889, 82.57603805, "212"],
[54.8834204167, 82.4653173333, "2/67"],
[54.8829550167, 82.4680045, "93A"],
[54.8815600333, 82.4786609667, "164C"],
[54.8830218167, 82.4623102, "41"],
[54.8817898333, 82.47891525, "166A"],
[54.8827127167, 82.46177765, "40"],
[54.8822979167, 82.4663795167, "74A"],
[54.8828493167, 82.4591475, "16"],
[54.88142475, 82.4786348833, "164D"],
[54.88306005, 82.4616891167, "37"],
[54.8820609167, 82.4740814833, "122"],
[54.8826992167, 82.4619383167, "42"],
[54.8821519667, 82.4815448333, "209A"],
[54.883041, 82.4620756167, "39"],
[54.8832654167, 82.4652926667, "1/67"],
[54.88272565, 82.4616287, "38"],
[54.8830076333, 82.4626069, "43"],
[54.8831357, 82.4601246167, "27"],
[54.8817307, 82.4761582, "146A"],
[54.8831685833, 82.4596908, "25"],
[54.8815906167, 82.4788964667, "166B"],
[54.88278065, 82.4602865167, "26"],
[54.8835589833, 82.4653321833, "3/67"],
[54.8825282667, 82.4646378, "60"],
[54.8813641333, 82.4755528333, "136A"],
[54.8823392167, 82.4748610333, "155"],
[54.8833277833, 82.46261325, "43A"],
[54.8815676833, 82.4731547, "114B"],
[54.8819471167, 82.4816728, "211"],
[54.8829108333, 82.4730159, "139"],
[54.8831197, 82.4654452, "69A"],
[54.8827723, 82.4605280167, "28"],
[54.8829114, 82.4647714833, "59"],
[54.88250115, 82.4649823, "64"],
[54.8829076, 82.46497065, "61"],
[54.88293875, 82.4727218, "135"],
[54.8824690167, 82.4726854833, "133"],
[54.88310945, 82.4604659833, "31"],
[54.8831059, 82.4608415833, "35"],
[54.8827654333, 82.4607287333, "30"],
[54.8831227667, 82.4602889167, "29"],
[54.8825220833, 82.4621568833, "44A"],
[54.88299765, 82.4628680167, "45"],
[54.8832516833, 82.4628885167, "45A"],
[54.8826944667, 82.46216875, "44"],
[54.8825202167, 82.46254835, "48A"],
[54.8833442667, 82.45699385, "5"],
[54.8829708667, 82.4632570667, "51"],
[54.8824811, 82.4725087833, "131"],
[54.8829959833, 82.4630565833, "49"],
[54.8826675833, 82.4625577, "48"],
[54.88331805, 82.45745235, "9"],
[54.8824531333, 82.47297485, "141"],
[54.8827041833, 82.45734235, "8"],
[54.8833336167, 82.4572248667, "7"],
[54.8829612, 82.4728780167, "137"],
[54.8823318333, 82.4686371167, "86"],
[54.8824054833, 82.4672578333, "78"],
[54.8823379667, 82.4683863333, "84A-84D"],
[54.8823962167, 82.4674496167, "80"],
[54.8824414833, 82.46633525, "74"],
[54.8827537667, 82.4672953, "85"],
[54.8822319333, 82.4661475333, "72"],
[54.8824802, 82.4658691833, "70"],
[54.8827660833, 82.4671242167, "83"],
[54.8823372667, 82.47505315, "157"],
[54.8826545167, 82.4751218167, "157A"],
[54.8820193333, 82.4750065167, "128"],
[54.8818626167, 82.4777718333, "152"],
[54.8819736, 82.47592125, "140"],
[54.8819698, 82.4757241667, "138"],
[54.8823149, 82.4754510833, "165"],
[54.8823264833, 82.4752907833, "163"],
[54.8827581167, 82.4752805833, "161"],
[54.8829257833, 82.4751779333, "159"],
[54.8822762, 82.4760006333, "167"],
[54.8821834, 82.4777217333, "177"],
[54.8822236833, 82.4803508667, "199"],
[54.8815487833, 82.4799515, "172A"],
[54.8821390333, 82.4785808167, "185"],
[54.8821657167, 82.4779489667, "179"],
[54.8821615, 82.47814015, "181"],
[54.8821482167, 82.4783480833, "183"],
[54.88205545, 82.4801785, "197"],
[54.8817139833, 82.48044315, "176"],
[54.8817403667, 82.4799308667, "172"],
[54.8817075, 82.4806324333, "176A"],
[54.8816647167, 82.4814856333, "184"],
[54.8817027333, 82.4808254167, "178"],
[54.8816651167, 82.48128865, "182"],
[54.8816775833, 82.4810764167, "180"],
[54.8821253667, 82.4788135833, "187"],
[54.88211265, 82.4790205167, "189"],
[54.88210465, 82.4792012833, "191"],
[54.8820355, 82.4804062667, "201"],
[54.88222755, 82.4806704167, "203A"],
[54.8820247167, 82.4806337333, "203"],
[54.8821983833, 82.4809817, "205A"],
[54.8820063, 82.4808974, "205"],
[54.8819872, 82.4811870167, "207"],
[54.88197265, 82.4814592667, "209"],
[54.8831150167, 82.4606360833, "33"],
[54.8827381667, 82.4614688333, "36"],
[54.88168275, 82.4731685667, "114A"],
[54.8825469333, 82.4624433, "46A"],
[54.8827017167, 82.4623766, "46"],
[54.8828950667, 82.4652071, "65"],
[54.88223365, 82.4708144, "98"],
[54.8826632333, 82.46886835, "99"],
[54.88294545, 82.4574472333, "10"],
[54.8820008, 82.47545635, "132"],
[54.8815931167, 82.4754940333, "134"],
[54.8815807333, 82.4756172833, "136"],
[54.8820043167, 82.4752607833, "130"],
[54.88218895, 82.4774782333, "82"],
[54.88172165, 82.4801884, "174"],
[54.8830567667, 82.4618380833, "37A"],
[54.88330235, 82.4576792167, "11"],
[54.8818654333, 82.4775383667, "150"],
[54.8826391333, 82.4630505, "50C"],
[54.8826306167, 82.4631781333, "50D"],
[54.8822323333, 82.46476475, "62"],
[54.8818249833, 82.4749363833, "128A"],
[54.8826051333, 82.4701299167, "109"],
[54.8822580667, 82.47622145, "169"],
[54.8821165333, 82.4729660833, "112"],
[54.8826087833, 82.4699331333, "107"],
[54.8819629, 82.4761853, "146"],
[54.882082833, 82.4748403667, "126"],
[54.8825933333, 82.4704919167, "113"],
[54.8825976, 82.4703054667, "111"],
[54.8815316833, 82.4759537667, "142"],
[54.8815485667, 82.4760951167, "144"],
[54.8826667167, 82.4685696833, "97A"],
[54.8823006, 82.4698174167, "90"],
[54.8822800167, 82.4702989667, "96"],
[54.8819513333, 82.47633525, "148"],
[54.8828277833, 82.4687268667, "97"],
[54.8822974333, 82.469983, "92"],
[54.8828276667, 82.4593929667, "18"],
[54.8823263167, 82.4688898, "88"],
[54.8832137, 82.4589384833, "17"],
[54.8822883667, 82.4701519667, "94"],
[54.8826732, 82.4684589667, "97B"],
[54.8822189833, 82.47111545, "100"],
[54.8820588, 82.4799191833, "195"],
[54.8817857167, 82.4791120667, "168"],
[54.8815184167, 82.4779607667, "156"],
[54.8831976333, 82.4593128167, "21"],
[54.8823417833, 82.4681742167, "82"],
[54.8827111, 82.4679744667, "93"],
[54.8832019667, 82.4591213833, "19"],
[54.8815556333, 82.4802543833, "174A"],
[54.88215085, 82.4723449167, "108"],
[54.8815176167, 82.4778254833, "154"],
[54.8820986333, 82.4731788833, "114"],
[54.8820722833, 82.47386775, "120"],
[54.8821363667, 82.4725972667, "110"],
[54.8818740833, 82.47394495, "120A"],
[54.8820951167, 82.4734228167, "116"],
[54.88208125, 82.4736554333, "118"],
[54.8816796667, 82.4786736667, "164B"],
[54.88313585, 82.4678512667, "91"],
[54.8824046833, 82.4740707, "153"],
[54.8829457667, 82.45767015, "12A"],
[54.8825498667, 82.45756275, "12"],
[54.8832922167, 82.4578983333, "13"],
[54.8829356167, 82.4578815, "14"],
[54.8832731833, 82.4580626167, "15"],
[54.8833720833, 82.4564383833, "1"],
[54.8833604167, 82.4567315167, "3"],
[54.8828452833, 82.4659509, "75"],
[54.88283615, 82.4661431333, "77"],
[54.8828280833, 82.4662871833, "79"],
[54.8831762333, 82.4650671667, "63A"],
[54.8832807333, 82.4650862667, "63B"],
[54.8828784, 82.4654325333, "69"],
[54.88286845, 82.4656069833, "71"],
[54.8828541167, 82.4657729833, "73"],
[54.88225265, 82.4763298333, "171"],
[54.88244025, 82.4731903833, "143"],
[54.88277745, 82.4714596167, "123A"],
[54.8825218833, 82.4714168, "123"],
[54.8826166167, 82.4697419333, "105"],
[54.88317465, 82.4595099667, "23"],
[54.88146045, 82.47846145, "162"],
[54.8818026833, 82.47869275, "164A"],
[54.8825380333, 82.47125165, "121"],
[54.8821686667, 82.4812678167, "207A"],
[54.8825423167, 82.47107055, "119"],
[54.8818212833, 82.4783825, "160"],
[54.8825595667, 82.4708636, "117"],
[54.8822055167, 82.4713504167, "104"],
[54.8821969167, 82.4715105167, "106"],
[54.88270855, 82.4681556333, "95"],
[54.8818339, 82.4781130167, "158"],
[54.88248225, 82.4723453, "129"],
[54.8825806, 82.4706828667, "115"],
[54.8824171833, 82.47368635, "149"],
[54.8830100833, 82.4662410333, "77A"],
[54.88294835, 82.4681855, "95A"],
[54.8824262667, 82.4734592, "147"],
[54.88256465, 82.4739109667, "151A"],
[54.88265405, 82.4627631667, "50A"],
[54.88273475, 82.4676983, "89"],
[54.8826450667, 82.4629121333, "50B"],
[54.8827506167, 82.4674962833, "87"],
[54.8824087, 82.4738996167, "151"],
[54.8752754167, 82.4687945, "5"],
[54.8762403, 82.4685664667, "17"],
[54.8754141333, 82.46920485, "7"],
[54.87579005, 82.4687529833, "11B"],
[54.8756581167, 82.4691656167, "9"],
[54.8765213333, 82.4682912, "19D"],
[54.8756935167, 82.46956425, "10"],
[54.87642715, 82.46787445, "19B"],
[54.8755152333, 82.4695951833, "8"],
[54.8764289167, 82.46891995, "20"],
[54.8753332833, 82.4696019833, "6"],
[54.8751625833, 82.4692038167, "3"],
[54.8751427, 82.4696164667, "4"],
[54.8764386833, 82.46867495, "21"],
[54.87496015, 82.4696499, "2"],
[54.8756744167, 82.4688181667, "11A"],
[54.8749777333, 82.4692451667, "1"],
[54.8763775667, 82.4681980333, "19A"],
[54.87626605, 82.46911145, "16"],
[54.8765451333, 82.4678920167, "19C"],
[54.87614825, 82.4692725667, "14"],
[54.87655055, 82.4693377, "18"],
[54.8760211, 82.4693800167, "12"],
[54.87610675, 82.46867635, "15"],
[54.8759566833, 82.4689563167, "13"],
[54.8746548333, 82.4923337833, "108"],
[54.8761834667, 82.4925171833, "86"],
[54.8786149333, 82.4916796167, "61"],
[54.8767351, 82.4913667333, "83"],
[54.8802232333, 82.49233165, "48"],
[54.8775048833, 82.4913709, "75"],
[54.8754266, 82.4923112333, "98"],
[54.8778063333, 82.4924615667, "72"],
[54.8803238667, 82.49186235, "45"],
[54.8723323333, 82.49117315, "131"],
[54.8718419, 82.4924310167, "138"],
[54.8711135, 82.4946030167, "148"],
[54.8697698833, 82.4923552333, "166"],
[54.8688831, 82.4922950167, "176"],
[54.8789681333, 82.4925074, "58"],
[54.8820738333, 82.4926333167, "30"],
[54.8812172, 82.49178955, "37"],
[54.88069745, 82.4925708333, "42"],
[54.8787213167, 82.4903820667, "63"],
[54.8789726667, 82.4909397833, "59"],
[54.8796000667, 82.498281167, "53"],
[54.8795261833, 82.49247645, "54"],
[54.8736368167, 82.4923986833, "124"],
[54.8727232333, 82.4924140333, "126"],
[54.87437165, 82.4674392167, "27"],
[54.8746732167, 82.4701863, "7"],
[54.8744574833, 82.4691624667, "17"],
[54.8743822167, 82.47024785, "9A"],
[54.8749997667, 82.4700487, "12"],
[54.8743498667, 82.4700893333, "9B"],
[54.8752501333, 82.4707564333, "4"],
[54.8746036167, 82.46989845, "11"],
[54.8744127333, 82.4663752333, "33"],
[54.87455375, 82.4696726333, "13"],
[54.87442195, 82.4683011333, "21"],
[54.87475005, 82.4704344167, "5"],
[54.8747738, 82.4664531833, "32"],
[54.8747376833, 82.4677991, "24"],
[54.8748038833, 82.4662112833, "34"],
[54.8743485, 82.4672374833, "29"],
[54.87475315, 82.4683317, "22"],
[54.8747034167, 82.4672897833, "28"],
[54.8751725667, 82.4705402833, "6"],
[54.8743703, 82.46656865, "31"],
[54.8747061667, 82.4675099333, "26"],
[54.8749663833, 82.4711516, "1"],
[54.8750729167, 82.4702726833, "10"],
[54.8747800333, 82.4687326833, "20"],
[54.8747974333, 82.468992, "18"],
[54.87484445, 82.4707471667, "3"],
[54.8754537333, 82.47035305, "8A"],
[54.8753716, 82.4710875, "2"],
[54.8749196, 82.4697604667, "14"],
[54.8744452, 82.4661277667, "35"],
[54.8744961833, 82.46941455, "15"],
[54.8747449667, 82.4666386167, "30"],
[54.87482605, 82.4692223833, "16"],
[54.8754105667, 82.4702048167, "8B"],
[54.8743849167, 82.4676931, "25"],
[54.8744337, 82.4689042667, "19"],
[54.8743984167, 82.4679389167, "23"],
[54.8778069667, 82.4712312167, "25"],
[54.8763120333, 82.4717215833, "44"],
[54.87672545, 82.4712506833, "41"],
[54.8772550667, 82.471782167, "32"],
[54.8668511333, 82.4718110667, "166"],
[54.8767613667, 82.4717327167, "40"],
[54.8733181333, 82.47092935, "81"],
[54.86564525, 82.47179185, "172"],
[54.866566, 82.47182225, "170"],
[54.8709313833, 82.472052, "102"],
[54.8773583833, 82.4709902333, "33A"],
[54.8718238, 82.4719052833, "100"],
[54.8636636, 82.4713474333, "185"],
[54.8639432, 82.4718744833, "180"],
[54.87639895, 82.4712276333, "43"],
[54.86320725, 82.47180795, "190"],
[54.87736335, 82.4707706667, "33B"],
[54.8635744667, 82.4721996167, "1/186"],
[54.8770291667, 82.4712897833, "37"],
[54.8744578833, 82.4712959833, "63"],
[54.87760745, 82.4717249167, "30"],
[54.8748192, 82.47130365, "59"],
[54.8647013333, 82.4717920833, "174"],
[54.8754668167, 82.4712709333, "55"],
[54.8748770833, 82.478243167, "62"],
[54.863631, 82.4717906, "186"],
[54.8759205833, 82.4712616667, "51"],
[54.86283285, 82.4713374833, "195"],
[54.8773474667, 82.4713414333, "35"],
[54.87610145, 82.4712462667, "47"],
[54.8736575, 82.4709245667, "75"],
[54.8743432333, 82.4718551833, "66"],
[54.86451155, 82.47179665, "176"],
[54.8735859667, 82.4719257333, "74"],
[54.8734058167, 82.47132365, "79"],
[54.8742359, 82.4712991333, "67"],
[54.87358325, 82.4713242167, "77"],
[54.87305765, 82.4719396833, "82"],
[54.8727949333, 82.4719115167, "86"],
[54.8722028667, 82.4741686, "90"],
[54.8675567167, 82.4711739833, "137"],
[54.8725890333, 82.46970215, "2/95"],
[54.8726248333, 82.4710150833, "1/95"],
[54.8702623, 82.4720475333, "116"],
[54.8780759667, 82.4717211333, "24"],
[54.8738727167, 82.4713038, "73"],
[54.8739672333, 82.4710486167, "71"],
[54.8935260167, 82.4748064, "10"],
[54.89273555, 82.4747373, "16"],
[54.8919345833, 82.4746388833, "24"],
[54.89328595, 82.4747852667, "12"],
[54.8938477333, 82.47430505, "8A"],
[54.8936160833, 82.47481635, "8"],
[54.8920694833, 82.4757293833, "23A"],
[54.89206575, 82.4752388667, "23"],
[54.8923724, 82.4746924667, "18"],
[54.89353315, 82.47444375, "10A"],
[54.8899805167, 82.4750166667, "41"],
[54.89167325, 82.4757043333, "27A"],
[54.89028415, 82.47505045, "39"],
[54.892463, 82.47526755, "17"],
[54.8918398667, 82.4752066, "25"],
[54.8908128167, 82.4750707333, "33"],
[54.8904636333, 82.4750504333, "37"],
[54.8906359833, 82.47507655, "35"],
[54.8916253, 82.47516515, "27"],
[54.8909492333, 82.47507265, "31"],
[54.8905761667, 82.4744542167, "1/30-5/30"],
[54.8881462333, 82.4754198167, "57"],
[54.88850555, 82.47524575, "53"],
[54.8894041667, 82.47498115, "45"],
[54.9014205, 82.4676039667, "9"],
[54.905282667, 82.4691138833, "53"],
[54.90503895, 82.46905685, "51"],
[54.90533595, 82.4686957333, "55"],
[54.90163855, 82.46769255, "17"],
[54.9033958, 82.4683840167, "35"],
[54.9053689667, 82.46858075, "57"],
[54.9012599667, 82.4679458667, "12"],
[54.9014051333, 82.4680825, "14"],
[54.9015679, 82.4680723333, "16"],
[54.9031653, 82.4679986833, "31A"],
[54.9007696333, 82.46734585, "1"],
[54.9017356333, 82.4681344333, "18"],
[54.9019312333, 82.46780625, "19"],
[54.9019026, 82.4682113333, "20"],
[54.9023515833, 82.4679880667, "23"],
[54.9025247833, 82.4680511, "25"],
[54.9019499, 82.46872425, "26"],
[54.9027011167, 82.4680964167, "27"],
[54.90322595, 82.4683034667, "33"],
[54.9022090667, 82.46834225, "28"],
[54.9028740333, 82.4681630167, "29"],
[54.9009473167, 82.4678397833, "2"],
[54.9030474, 82.46823325, "31"],
[54.9024255333, 82.4684154833, "32"],
[54.9024751, 82.4690537, "34A"],
[54.9025607, 82.4684754, "34"],
[54.9047760167, 82.4688679333, "49"],
[54.9035690833, 82.46844705, "37"],
[54.9032248, 82.4687414833, "38"],
[54.9037398833, 82.4685398, "39"],
[54.90425835, 82.4687235833, "45"],
[54.9039185, 82.4686071, "41"],
[54.9040853333, 82.4686607667, "43"],
[54.9044377833, 82.46879205, "47"],
[54.9027932167, 82.4685815833, "36"],
[54.90099425, 82.46709335, "3"],
[54.90111195, 82.4678951333, "4"],
[54.9010127333, 82.4674434667, "5"],
[54.9012417333, 82.4675368333, "7"],
[54.9054492167, 82.4684984667, "59"],
[54.9055391, 82.4685278333, "61"],
[54.90550535, 82.46878055, "63"],
[54.9054566667, 82.46921805, "65"],
[54.90230745, 82.4676206667, "21A"],
[54.9021682, 82.4679036667, "21"],
[54.8808262333, 82.4773818, "55A"],
[54.8830005833, 82.4767448167, "16"],
[54.8828296667, 82.4767286, "18"],
[54.88259875, 82.4772334333, "31"],
[54.8824754, 82.47721195, "33"],
[54.8831398167, 82.4779190333, "17"],
[54.8825963167, 82.4777829, "29"],
[54.8842646833, 82.4768462333, "2"],
[54.8810851333, 82.476127, "36"],
[54.8806964, 82.47760075, "57"],
[54.8805952167, 82.4775984333, "59"],
[54.8813687667, 82.4765958833, "32"],
[54.8824115167, 82.4772049833, "35"],
[54.8811797, 82.4765765833, "34"],
[54.8815471667, 82.4766046333, "30"],
[54.88417235, 82.4773933667, "3"],
[54.88174695, 82.4772075667, "39"],
[54.8809885833, 82.47654575, "38"],
[54.8814635333, 82.4771838167, "43"],
[54.8816058667, 82.4771958, "41"],
[54.88064845, 82.4765253, "42"],
[54.8808178333, 82.4765337333, "40"],
[54.883982, 82.4773589667, "5"],
[54.8834955667, 82.4767355667, "10"],
[54.88350755, 82.4765409, "10A"],
[54.8836987667, 82.47736385, "7"],
[54.88321935, 82.4767625833, "12"],
[54.8833260667, 82.4773372, "13"],
[54.8830089, 82.4772931833, "19A"],
[54.8831393167, 82.4773106833, "19"],
[54.88264695, 82.47671705, "20"],
[54.88292945, 82.4775952333, "21"],
[54.8824614333, 82.4767002833, "22"],
[54.8828817167, 82.4779039, "23"],
[54.8823059167, 82.4766897833, "24"],
[54.8827997667, 82.4772721833, "25A"],
[54.8828034167, 82.4775536833, "25B"],
[54.8827016667, 82.4777941, "27"],
[54.8828062, 82.47779805, "27A"],
[54.8817341833, 82.4766062333, "28"],
[54.8813136167, 82.4771594167, "45"],
[54.8811630667, 82.4771457, "47"],
[54.8809942833, 82.4776755833, "51"],
[54.8804464667, 82.4764969833, "44"],
[54.8810737, 82.4776356667, "49"],
[54.8809778333, 82.4774265, "53A"],
[54.8810030333, 82.4771406667, "53"],
[54.88079105, 82.47712645, "55"],
[54.8835414333, 82.4773520667, "9"],
[54.8805955667, 82.4771014667, "61"],
[54.8804778167, 82.4770884667, "63"],
[54.8802896833, 82.4770558, "65"],
[54.8834467833, 82.4778119333, "11"],
[54.8878083, 82.4623779167, "49A"],
[54.8872817833, 82.45737585, "10"],
[54.8877537333, 82.4595533, "27A"],
[54.8884375167, 82.45748685, "11B"],
[54.8878958, 82.4596416167, "27B"],
[54.88824535, 82.45746395, "11A"],
[54.8875099833, 82.4575973667, "14"],
[54.8866716167, 82.4603215333, "36B"],
[54.8871296333, 82.4604902833, "36C"],
[54.8873681333, 82.4599526667, "30"],
[54.8880297, 82.4601033833, "31A"],
[54.8881606833, 82.4601333667, "31B"],
[54.8869335833, 82.4608386833, "40A"],
[54.8873096333, 82.4609038, "40"],
[54.8878578167, 82.4576188333, "13"],
[54.8871150667, 82.4574956333, "12"],
[54.8878406333, 82.45785455, "15"],
[54.8871478667, 82.4578061667, "16A"],
[54.8869680833, 82.4578044667, "16B"],
[54.8874965167, 82.4577967, "16"],
[54.8872507333, 82.4580158333, "18A"],
[54.88747815, 82.4580365167, "18"],
[54.8880638833, 82.45810725, "19A"],
[54.88784345, 82.4580772667, "19"],
[54.8877572333, 82.45932705, "25"],
[54.8879145667, 82.45669455, "1"],
[54.8873702833, 82.4595467333, "26"],
[54.8879238167, 82.4569262833, "1A"],
[54.8874736, 82.4582577833, "20"],
[54.8878260333, 82.4583038167, "21"],
[54.8873656333, 82.4597425833, "28"],
[54.8879435667, 82.4597720333, "29A"],
[54.8881376167, 82.45977945, "29B"],
[54.8883413667, 82.4597758333, "29C"],
[54.8884945333, 82.45978905, "29D"],
[54.8877360167, 82.45978725, "29"],
[54.8871679167, 82.4598937333, "30A"],
[54.8877368167, 82.45999715, "31"],
[54.8873456, 82.4602082167, "32"],
[54.8877073333, 82.4602192333, "33"],
[54.88687805, 82.4602032667, "34A"],
[54.8866636, 82.4602061833, "34B"],
[54.8868802667, 82.4603641333, "36A"],
[54.8877013333, 82.4604213, "35"],
[54.8875414167, 82.4568279333, "2"],
[54.8873298167, 82.4604643167, "36"],
[54.8876929833, 82.4606236833, "37"],
[54.8869503167, 82.4606911333, "38A"],
[54.8873173833, 82.46064935, "38"],
[54.8880788167, 82.46095015, "39A"],
[54.8876923833, 82.4607943167, "39"],
[54.88767155, 82.4610391833, "41"],
[54.8876050833, 82.4618428, "43"],
[54.8876116333, 82.4619894, "45"],
[54.88820765, 82.4571291333, "3A"],
[54.88840855, 82.4571648833, "3B"],
[54.8875992833, 82.4621293167, "47"],
[54.88757835, 82.4622876333, "49"],
[54.8875702, 82.4625005667, "51"],
[54.8875504, 82.46284035, "53"],
[54.8875351833, 82.46302475, "55"],
[54.88811905, 82.4635122, "57E"],
[54.88825965, 82.46351715, "57F"],
[54.8882625, 82.4633885, "57G"],
[54.8882589333, 82.4632448167, "57H"],
[54.8875218833, 82.4632180167, "57"],
[54.8875030667, 82.4634566667, "59"],
[54.8871363, 82.4643333667, "64"],
[54.88744265, 82.4645542333, "65"],
[54.8871286333, 82.4645791667, "66"],
[54.8876065667, 82.4648085833, "67A"],
[54.8874482, 82.4647992167, "67"],
[54.88711895, 82.4648136, "68"],
[54.8885710333, 82.4571354, "5A"],
[54.8886647667, 82.4571676667, "5B"],
[54.8874510667, 82.4649796333, "69A"],
[54.8875224833, 82.4649906833, "69B"],
[54.8878563833, 82.4571620833, "7A"],
[54.8880328667, 82.4571656833, "7B"],
[54.8875264167, 82.4573541, "8"],
[54.88804485, 82.4574312167, "9B"],
[54.8875345667, 82.4570015833, "6"],
[54.8878647667, 82.45740435, "9A"],
[54.8879745833, 82.4634900667, "57D"],
[54.8878037333, 82.4633596833, "57B"],
[54.8878387167, 82.4631928333, "57A"],
[54.8878102333, 82.46349065, "57C"],
[54.9019538167, 82.4671126833, "7A"],
[54.903244, 82.4676256333, "14A"],
[54.9020871667, 82.4668353167, "7"],
[54.9027623667, 82.4671213167, "11"],
[54.9025892667, 82.4670505333, "10"],
[54.9024684667, 82.4672691667, "10A"],
[54.90241945, 82.4669742667, "9"],
[54.9029300667, 82.4671840333, "12"],
[54.90311145, 82.4672579333, "13"],
[54.9032782833, 82.4673314833, "14"],
[54.9036218833, 82.4674643167, "16"],
[54.9037919667, 82.46753785, "17"],
[54.90344895, 82.4673941667, "15"],
[54.9039705667, 82.4676045333, "18"],
[54.9041435833, 82.467671, "19"],
[54.9010125167, 82.4664210333, "1A"],
[54.9007809667, 82.4663229167, "1"],
[54.9043140333, 82.4677303167, "20"],
[54.90448985, 82.46780755, "21"],
[54.9046493333, 82.4670530667, "23"],
[54.9048533833, 82.4675182833, "24"],
[54.9012388167, 82.46653205, "2"],
[54.9014534667, 82.46660645, "4"],
[54.9017320167, 82.4669518333, "5"],
[54.9018944667, 82.4667655333, "6"],
[54.9022384667, 82.46689735, "8"],
[54.90570045, 82.46976825, "72/91"],
[54.9051381333, 82.4722857333, "96"],
[54.9032204, 82.4703621333, "53"],
[54.9053162167, 82.4723414, "98"],
[54.9037962833, 82.4711215833, "5/91"],
[54.9055880667, 82.4707876167, "108/91"],
[54.9045404333, 82.4699855167, "46/91"],
[54.9016813667, 82.4703439167, "17"],
[54.9047542667, 82.4700433333, "48/91"],
[54.9038862333, 82.4703755167, "31/91"],
[54.9046661667, 82.4695472667, "56/91"],
[54.9033795167, 82.4706831, "10/91"],
[54.9049449167, 82.4696617167, "54/91"],
[54.90342665, 82.4705010167, "26/91"],
[54.9042283333, 82.4698824, "43/91"],
[54.9034820167, 82.4702482, "27/91"],
[54.9041029833, 82.471257, "3/91"],
[54.9035045167, 82.47071685, "11/91"],
[54.9034292833, 82.4709543667, "8/91"],
[54.9035455167, 82.4705136333, "25/91"],
[54.9044278, 82.4696974167, "52/91"],
[54.9036199667, 82.4702949333, "28/91"],
[54.9050604833, 82.4696742167, "53/91"],
[54.9035777167, 82.4701138, "29/91"],
[54.9047726833, 82.46981425, "49/91"],
[54.9037153, 82.4701772333, "30/91"],
[54.90366135, 82.4710693333, "6/91"],
[54.9036912333, 82.4708029167, "12/91"],
[54.9039544333, 82.4701398833, "39/91"],
[54.90384865, 82.4708670667, "13/91"],
[54.90441965, 82.4694715667, "58/91"],
[54.9039537167, 82.4709042667, "14/91"],
[54.9048014667, 82.46941845, "66/91"],
[54.90397155, 82.4704078333, "32/91"],
[54.9046743167, 82.4697731167, "50/91"],
[54.9040982, 82.4709554167, "15/91"],
[54.9049822333, 82.4694750833, "67/91"],
[54.9042064833, 82.4709969, "16/91"],
[54.9039450167, 82.4711861667, "4/91"],
[54.9043704167, 82.47106545, "17/91"],
[54.9045624167, 82.4693054333, "64/91"],
[54.90449515, 82.4711117167, "18/91"],
[54.9040047, 82.46996625, "40/91"],
[54.9038797333, 82.4706635, "24/91"],
[54.9035451833, 82.4710177667, "7/91"],
[54.9039780833, 82.4707046333, "23/91"],
[54.9045066833, 82.46972115, "51/91"],
[54.9041615833, 82.4707864333, "22/91"],
[54.9060640333, 82.4699358833, "91/91"],
[54.9042534333, 82.47082315, "21/91"],
[54.9047130333, 82.4693776833, "65/91"],
[54.9044305, 82.47089635, "20/91"],
[54.9043041167, 82.46989765, "44/91"],
[54.9041919167, 82.4691500833, "61/91"],
[54.9044746667, 82.46996645, "45/91"],
[54.9042904667, 82.4691828667, "62/91"],
[54.9040487167, 82.4697756833, "41/91"],
[54.90415055, 82.4693699833, "60/91"],
[54.90446065, 82.46926835, "63/91"],
[54.9042810333, 82.46945405, "59/91"],
[54.9032851, 82.4708958667, "9/91"],
[54.90451895, 82.4709371333, "19/91"],
[54.9045116833, 82.4694999333, "57/91"],
[54.9040854167, 82.4704954667, "33/91"],
[54.9043916, 82.4713621667, "1/91"],
[54.9041970167, 82.4705370833, "34/91"],
[54.9050893833, 82.46956665, "68/91"],
[54.9043310833, 82.4706087333, "35/91"],
[54.9040848, 82.4696433167, "42/91"],
[54.90443305, 82.4706374667, "36/91"],
[54.90476785, 82.4695885167, "55/91"],
[54.9045282833, 82.4706701333, "37/91"],
[54.9042286667, 82.471303, "2/91"],
[54.90462665, 82.4707112667, "38/91"],
[54.9046719667, 82.4700236667, "47/91"],
[54.9063787833, 82.47006835, "93/91"],
[54.9052918833, 82.4698329167, "76/91"],
[54.9052114833, 82.4700221833, "77/91"],
[54.9050883833, 82.4701973667, "79/91"],
[54.9053839167, 82.4698613, "75/91"],
[54.9052999333, 82.47006295, "78/91"],
[54.9051933667, 82.47023875, "80/91"],
[54.9052919167, 82.4702715333, "81/91"],
[54.9055609, 82.4699386667, "74/91"],
[54.9056495333, 82.4699711, "73/91"],
[54.9054736, 82.4701402167, "82/91"],
[54.9063660167, 82.4715132167, "102/91"],
[54.9062675667, 82.4719148667, "118/91"],
[54.9062345, 82.4720598833, "134/91"],
[54.9061993167, 82.4712732833, "104/91"],
[54.9061410333, 82.4715093, "117/91"],
[54.90608265, 82.4717494667, "119/91"],
[54.9060274833, 82.47199395, "133/91"],
[54.9059191, 82.4719566333, "132/91"],
[54.9059778667, 82.47169975, "120/91"],
[54.90603625, 82.4714595667, "116/91"],
[54.9061060667, 82.4711529667, "105/91"],
[54.9053162667, 82.4716843, "137/91"],
[54.9055131833, 82.478282167, "136/91"],
[54.9055088, 82.471073, "112/91"],
[54.9056170833, 82.4711144833, "113/91"],
[54.9057647667, 82.4711699333, "114/91"],
[54.9058762667, 82.4712157167, "115/91"],
[54.9054861167, 82.4707589, "109/91"],
[54.9055522167, 82.4701764667, "83/91"],
[54.9057089833, 82.4702698167, "84/91"],
[54.9058203833, 82.4703197833, "85/91"],
[54.90590455, 82.4701097667, "89/91"],
[54.9059963, 82.4701506667, "88/91"],
[54.90573235, 82.4708471167, "107/91"],
[54.9061820167, 82.4702237333, "87/91"],
[54.9062864333, 82.4702866167, "86/91"],
[54.9058177667, 82.47087525, "106/91"],
[54.9064954833, 82.4701769667, "94/91"],
[54.9065182667, 82.4703407, "95/91"],
[54.90647405, 82.4705396167, "96/91"],
[54.906434, 82.4707011, "97/91"],
[54.9064003667, 82.47087115, "98/91"],
[54.9065184833, 82.4709171667, "100/91"],
[54.9053462, 82.4696260167, "69/91"],
[54.9054348333, 82.46965845, "70/91"],
[54.9056151167, 82.4697359333, "71/91"],
[54.9065477667, 82.4707929167, "99/91"],
[54.9063361667, 82.4716625167, "103/91"],
[54.9064024833, 82.47136415, "101/91"],
[54.9062771167, 82.4700270833, "92/91"],
[54.90561825, 82.4717954167, "135/91"],
[54.9052021167, 82.4714629667, "127/91"],
[54.9053039667, 82.4714958833, "128/91"],
[54.9055797833, 82.4715935333, "130/91"],
[54.9057338, 82.4716617333, "131/91"],
[54.9054388, 82.47153415, "129/91"],
[54.90521165, 82.4711876167, "126/91"],
[54.9053168167, 82.47122065, "125/91"],
[54.9054577833, 82.4712800167, "124/91"],
[54.9055496333, 82.47131675, "123/91"],
[54.9057004333, 82.47138065, "122/91"],
[54.9057989, 82.4714176167, "121/91"],
[54.9052758833, 82.4709810667, "110/91"],
[54.9053744333, 82.4710138667, "111/91"],
[54.9029642833, 82.4708119167, "49"],
[54.9013200667, 82.47020055, "9"],
[54.9059721, 82.4699033333, "90/91"],
[54.9009692833, 82.4700359167, "1"],
[54.9020093333, 82.4704903167, "25"],
[54.9028505, 82.4713808167, "42"],
[54.9026220667, 82.4707023167, "41"],
[54.9030775167, 82.47144105, "44"],
[54.9032627, 82.4715188333, "46"],
[54.90279945, 82.4707535, "47"],
[54.9034596333, 82.4715854667, "48"],
[54.9046305667, 82.4720644, "90"],
[54.9048369667, 82.472151, "92"],
[54.9049919, 82.4722146, "94"],
[54.9036494333, 82.4716701167, "50"],
[54.90358525, 82.4846141, "12"],
[54.9037579, 82.4852529, "6"],
[54.9038024667, 82.4850978, "7"],
[54.9037217667, 82.4849037333, "8"],
[54.90347035, 82.4850285667, "2"],
[54.9032276333, 82.48546265, "3"],
[54.9035196167, 82.4852706167, "4"],
[54.9036445667, 82.4853146167, "5"],
[54.893842, 82.4658828667, "14"],
[54.8942232167, 82.4658869, "10"],
[54.8942694, 82.4655608, "10A"],
[54.8939012167, 82.46629055, "11"],
[54.89414105, 82.46563135, "12A"],
[54.8940382, 82.4658608667, "12"],
[54.8928791667, 82.4657609, "18"],
[54.8920411833, 82.4656866167, "26"],
[54.8947138333, 82.46562585, "4A"],
[54.89482635, 82.4656405333, "4B"],
[54.8943928667, 82.4659067667, "8"],
[54.89417895, 82.4666384333, "7A"],
[54.8941652333, 82.4663256, "7"],
[54.8930164333, 82.4657825333, "16"],
[54.8945337167, 82.46636655, "3"],
[54.8947049667, 82.4662976667, "1"],
[54.8943467167, 82.4663510667, "5"],
[54.8945939667, 82.46589925, "6A"],
[54.8946026667, 82.4655432, "6B"],
[54.89400605, 82.4666357, "9A"],
[54.89400415, 82.4663002333, "9"],
[54.8947237, 82.4659225, "4"],
[54.8948905833, 82.4659464167, "2"],
[54.8926863, 82.465739, "20"],
[54.8923385, 82.4654623833, "24B"],
[54.89249375, 82.4657308833, "22"],
[54.8923111667, 82.4657147167, "24"],
[54.8815449167, 82.4655157, "12"],
[54.8822096833, 82.4655813667, "2"],
[54.88233595, 82.4651839667, "1"],
[54.8816413667, 82.4648852333, "9B"],
[54.8828295, 82.4651827, "3"],
[54.8816216167, 82.4650913833, "9A"],
[54.8814350167, 82.4653094667, "13"],
[54.8813971333, 82.4649169833, "11B"],
[54.8814120833, 82.4650868167, "11A"],
[54.8819977833, 82.4651571333, "5"],
[54.8818037833, 82.46516125, "7"],
[54.9272509333, 82.5707935167, "17"],
[54.92487165, 82.5688565167, "50"],
[54.9279805, 82.5715888167, "2/4"],
[54.9281482167, 82.57159225, "3/4"],
[54.9277371667, 82.5716141833, "1/4"],
[54.9283277667, 82.5715995333, "4/4"],
[54.9259907667, 82.5697310833, "41"],
[54.9139028667, 82.4794934333, "16"],
[54.9131072667, 82.4784122, "5"],
[54.913859, 82.4793484, "14"],
[54.9137596833, 82.4789706167, "10"],
[54.9129783833, 82.4779572167, "1"],
[54.9134818333, 82.4796230333, "13"],
[54.9134313, 82.47942965, "11"],
[54.9130481833, 82.4781893667, "3"],
[54.9136100333, 82.4785928, "8"],
[54.9137780667, 82.47816635, "6A"],
[54.9134069333, 82.4779523167, "2"],
[54.9134797167, 82.4781646167, "4"],
[54.9135479833, 82.4783853833, "6"],
[54.9074968667, 82.4759960667, "26"],
[54.90790835, 82.4788683333, "53"],
[54.9077523333, 82.47593355, "26A"],
[54.9075665667, 82.47624025, "30"],
[54.9073841167, 82.47837545, "45"],
[54.90830365, 82.4786741167, "52"],
[54.9087247333, 82.4801247333, "64"],
[54.9075075667, 82.478882333, "51"],
[54.9088166, 82.4804266333, "66"],
[54.9082595167, 82.4801578667, "65"],
[54.9082304, 82.47843325, "50"],
[54.90781645, 82.4785779, "49"],
[54.9083352333, 82.48044785, "67"],
[54.9065845333, 82.4744138667, "15"],
[54.9069974, 82.47423525, "12"],
[54.9065571167, 82.4727805333, "2"],
[54.9066387833, 82.47305845, "4"],
[54.9068011, 82.4735746167, "8"],
[54.90669225, 82.47329415, "6"],
[54.9072826667, 82.4752864833, "18"],
[54.9081420333, 82.47812825, "44"],
[54.9076585, 82.47803815, "43"],
[54.9079773, 82.4776514, "42"],
[54.9080697, 82.4779212, "42A"],
[54.90758785, 82.4777916167, "41"],
[54.90774285, 82.4783192, "47"],
[54.9085469333, 82.47804035, "46"],
[54.907853, 82.4771642833, "40"],
[54.90694245, 82.4762600833, "27A"],
[54.90714115, 82.4762523167, "27"],
[54.9085940333, 82.4781931, "48"],
[54.90842915, 82.4807205833, "69"],
[54.90889165, 82.4806537667, "68"],
[54.9090825167, 82.4813461833, "72"],
[54.9085069833, 82.48098455, "71"],
[54.9091493333, 82.4815615167, "74"],
[54.9085867333, 82.4812446833, "73"],
[54.90638345, 82.4737115833, "9"],
[54.9073718833, 82.4770443667, "35"],
[54.9076616333, 82.4765182, "34"],
[54.9070147167, 82.4757612667, "19"],
[54.9080529667, 82.4794295333, "61"],
[54.9081081167, 82.4796110667, "63"],
[54.9067812333, 82.4766508667, "29"],
[54.90727425, 82.4767382167, "33"],
[54.9080598, 82.4763364, "32"],
[54.9080013, 82.4761604, "32A"],
[54.9072168667, 82.4765151833, "31"],
[54.9069078, 82.47611375, "21A"],
[54.9070925167, 82.4759961167, "21"],
[54.9073595833, 82.4755532, "20"],
[54.9078311, 82.47552015, "22"],
[54.9066715333, 82.4762365333, "23"],
[54.9074292167, 82.4757909, "24"],
[54.9067200667, 82.4763614333, "25"],
[54.9079507667, 82.47594195, "28"],
[54.9077839333, 82.4769487333, "38"],
[54.9087032167, 82.478581, "54"],
[54.9075582, 82.4791360667, "55"],
[54.9087507167, 82.47871815, "56"],
[54.9075607333, 82.4792694833, "57"],
[54.9085885667, 82.4789704, "58A"],
[54.908387, 82.47897535, "58"],
[54.9078259667, 82.4793328833, "59A"],
[54.90801855, 82.47915195, "59"],
[54.90845065, 82.4792147, "60"],
[54.9086727, 82.4815190333, "75"],
[54.9092022333, 82.4817325833, "76"],
[54.9087436333, 82.4817835, "77"],
[54.9068335333, 82.475831, "19A"],
[54.9064835, 82.4740658167, "11"],
[54.9068924667, 82.4738985333, "10"],
[54.90772245, 82.47673845, "36"],
[54.9153057833, 82.4700439333, "8"],
[54.9151920167, 82.470103, "7"],
[54.9154897833, 82.4704254667, "4"],
[54.91544255, 82.4701449833, "6"],
[54.9152406333, 82.4705098833, "3"],
[54.9155660833, 82.47067085, "2"],
[54.9153145667, 82.470762, "1"],
[54.915152, 82.4703036833, "5"],
[54.8753657, 82.4666292833, "7"],
[54.8752355833, 82.4664042833, "5"],
[54.8751239167, 82.4667343, "3"],
[54.8749005333, 82.4667724833, "1"],
[54.8759491, 82.4666146833, "13"],
[54.8761423333, 82.4666642667, "15"],
[54.8757443667, 82.46657535, "11"],
[54.8755500833, 82.4665719333, "9"],
[54.8762191, 82.4673812833, "18"],
[54.8764603333, 82.4671767333, "22"],
[54.87631595, 82.4667095833, "17"],
[54.8765421, 82.4670481833, "23"],
[54.8764974333, 82.4666557, "19"],
[54.8765351667, 82.46685605, "21"],
[54.8763332, 82.4671934833, "20"],
[54.8761136667, 82.4670612333, "16"],
[54.8759115833, 82.4670291, "14"],
[54.8757069333, 82.4669862167, "12"],
[54.87555015, 82.4673181667, "10"],
[54.8754323167, 82.4670474333, "8"],
[54.8752163333, 82.4671320667, "6"],
[54.8750437, 82.4671685, "4"],
[54.87486615, 82.4671727833, "2"],
[54.8836992833, 82.4725036, "23A"],
[54.8827955833, 82.47167325, "34"],
[54.88383525, 82.47247865, "21B"],
[54.8836711, 82.4721970333, "23"],
[54.88384845, 82.4721985333, "21A"],
[54.8832467333, 82.4721379, "31"],
[54.8852774167, 82.4718275333, "10"],
[54.8841115833, 82.4722314667, "17"],
[54.882555, 82.4720817333, "41"],
[54.8814569667, 82.4715107167, "46"],
[54.8826952667, 82.4720762667, "39"],
[54.8834193, 82.4725388, "27"],
[54.8834190667, 82.47216485, "29"],
[54.8835037667, 82.4725855, "25"],
[54.88308205, 82.4721211333, "33"],
[54.88081245, 82.47212895, "67A"],
[54.8808169167, 82.4719355833, "67"],
[54.8854703, 82.4715485833, "8A"],
[54.8854802667, 82.4723117333, "7"],
[54.8819775333, 82.4720601833, "45"],
[54.8820338, 82.4715768333, "38"],
[54.88505425, 82.4725552, "11A"],
[54.8816020167, 82.4715219833, "44"],
[54.8818502167, 82.4715604167, "40"],
[54.8817451, 82.4715327167, "42"],
[54.8817693333, 82.4720335, "47"],
[54.8826490167, 82.4716679, "36"],
[54.882937, 82.4720998667, "35"],
[54.8828116667, 82.4720924167, "37"],
[54.8851022, 82.4718166333, "12"],
[54.8817387667, 82.47236985, "49"],
[54.8812409667, 82.4710926333, "50"],
[54.8815675333, 82.4723074, "51A"],
[54.8816046833, 82.4720110833, "51"],
[54.8812419, 82.4709490833, "52"],
[54.8811635333, 82.4709188667, "54"],
[54.8814256833, 82.47197785, "55"],
[54.8811236333, 82.4712705167, "56"],
[54.8811993, 82.4719696333, "57"],
[54.88108405, 82.4714977167, "58"],
[54.8809842667, 82.4719474833, "59"],
[54.8809340167, 82.4725577, "61"],
[54.8808571667, 82.47147535, "62A"],
[54.8808698167, 82.4712961833, "62B"],
[54.88095885, 82.4727073167, "63"],
[54.8805953667, 82.471471, "64"],
[54.8808394, 82.4727179833, "65"],
[54.8856441667, 82.4723274, "5"],
[54.8856559833, 82.47193445, "6A"],
[54.8858045667, 82.4719521, "6"],
[54.8854608833, 82.4718410833, "8"],
[54.8852512333, 82.4722922833, "9"],
[54.8812897833, 82.47150895, "48"],
[54.8846497167, 82.4717921833, "18"],
[54.8850509167, 82.4722740667, "11"],
[54.8849657833, 82.4718045667, "14"],
[54.8863145, 82.47202075, "4"],
[54.8863136833, 82.4724193333, "3"],
[54.8848130833, 82.4725039833, "13A"],
[54.8848266333, 82.47225735, "13"],
[54.8839960167, 82.4722167, "19"],
[54.8848076833, 82.47180565, "16"],
[54.8847455833, 82.4722526833, "15"],
[54.8850477, 82.4726911167, "11B"],
[54.8941738167, 82.4707689, "84D"],
[54.8940840667, 82.4708939333, "84C"],
[54.8941785, 82.4709219, "84B"],
[54.8941324333, 82.47094385, "84A"],
[54.8935136, 82.4612187667, "11"],
[54.8939243167, 82.4608987333, "10"],
[54.8933340667, 82.4717043167, "100"],
[54.8936952, 82.4650319333, "42"],
[54.8932683, 82.4655177833, "41"],
[54.8936863667, 82.46521985, "44"],
[54.8936738833, 82.4655087667, "46"],
[54.8938362667, 82.4624257833, "22"],
[54.8937817, 82.4635414833, "30"],
[54.8938118, 82.4643993167, "40A"],
[54.8937340833, 82.4643627, "40"],
[54.8935297167, 82.4682022667, "68"],
[54.8932907833, 82.4653249667, "39"],
[54.8935900167, 82.4670001333, "54"],
[54.89330695, 82.4650841, "37"],
[54.8927154833, 82.4709052, "65B"],
[54.8927901, 82.4708936667, "65A"],
[54.8927898667, 82.4705552833, "63A"],
[54.8930308333, 82.461289, "13A"],
[54.8932869167, 82.46127415, "13"],
[54.89365705, 82.4657872833, "48"],
[54.8939401, 82.46390025, "32A"],
[54.8936144167, 82.4665801333, "52"],
[54.89383355, 82.4665993833, "52A"],
[54.8932530667, 82.47349375, "120"],
[54.8934369833, 82.4623886667, "19"],
[54.8942868333, 82.4610974, "12"],
[54.89390075, 82.46130575, "14"],
[54.8934877, 82.4615844, "15"],
[54.89438475, 82.4619340667, "16A"],
[54.89440795, 82.46167145, "16"],
[54.89348165, 82.4617730167, "17"],
[54.8938709333, 82.46165795, "18"],
[54.8933871167, 82.4633617, "27"],
[54.8934256333, 82.46270255, "21"],
[54.8934101, 82.4630095833, "23"],
[54.8938231667, 82.4626998167, "24"],
[54.8938185, 82.4629043667, "26"],
[54.8933327, 82.4599851667, "1"],
[54.8938655, 82.4619277667, "20"],
[54.8933737667, 82.4636349, "29"],
[54.8933599167, 82.4638405667, "31"],
[54.8937605833, 82.4638030667, "32"],
[54.8933501333, 82.4640728, "33"],
[54.89409735, 82.4639711333, "34"],
[54.89333535, 82.46433465, "35"],
[54.8937382833, 82.4641705, "36"],
[54.8938094833, 82.46310885, "28"],
[54.8937422833, 82.4642690333, "38"],
[54.8932706, 82.46028355, "3A"],
[54.8934162167, 82.4602382333, "3"],
[54.8935366333, 82.4605623667, "5"],
[54.8935312, 82.4607884833, "7"],
[54.89396845, 82.4602069333, "8"],
[54.8935128167, 82.4609781167, "9"],
[54.8932981167, 82.47301005, "108"],
[54.8932691667, 82.4732267667, "110"],
[54.8936267667, 82.47335325, "112A"],
[54.8938256167, 82.4733656, "112B"],
[54.8936103333, 82.4733669833, "112"],
[54.8937215333, 82.4735637667, "114"],
[54.89365715, 82.4738653167, "116"],
[54.8935390333, 82.4735507333, "118"],
[54.8934577667, 82.4693120833, "70"],
[54.8929881833, 82.4703184667, "59"],
[54.8929812667, 82.4706668833, "63"],
[54.8929615667, 82.47086305, "65"],
[54.8929371167, 82.4712434167, "69"],
[54.8929520667, 82.47105645, "67"],
[54.89367425, 82.46743525, "58A"],
[54.8937744667, 82.4673928, "58B"],
[54.8935667833, 82.46736855, "58"],
[54.89367375, 82.4675524167, "60A"],
[54.8937666333, 82.4676028333, "60B"],
[54.8935516833, 82.46756615, "60"],
[54.8935477333, 82.4677751333, "62"],
[54.8935387833, 82.4679283333, "64"],
[54.8935372333, 82.4680373167, "66"],
[54.8934518, 82.4694155833, "72"],
[54.8934506167, 82.4695295167, "74"],
[54.8934785833, 82.4697087167, "76"],
[54.8934174, 82.4705130167, "82"],
[54.8934133, 82.4707143833, "84"],
[54.89339765, 82.4708925667, "86"],
[54.8937520167, 82.4710181667, "88"],
[54.8933705, 82.47113315, "90"],
[54.8934223167, 82.4702347833, "78"],
[54.8933635, 82.4712602167, "92"],
[54.8933623333, 82.4713753167, "94"],
[54.89334455, 82.4715971333, "98"],
[54.8933610333, 82.4714828333, "96"],
[54.89307625, 82.4690541333, "2/53"],
[54.8930733667, 82.46912325, "3/53"],
[54.8930706333, 82.4691856, "4/53"],
[54.89306775, 82.4692547333, "5/53"],
[54.8930755833, 82.4687906833, "47"],
[54.8930806333, 82.4689783167, "1/53"],
[54.8937726, 82.46406345, "36A"],
[54.8940399167, 82.4626443667, "24A"],
[54.89306665, 82.4694318, "57A"],
[54.8929485833, 82.4694292, "57B"],
[54.893691, 82.4662858833, "50"],
[54.892929, 82.4695717833, "57C"],
[54.8818993667, 82.48831235, "10"],
[54.8819047, 82.4884493667, "9"],
[54.8818925167, 82.4887367833, "8"],
[54.8817909833, 82.4886448, "7"],
[54.88156225, 82.4884151333, "5"],
[54.8816410667, 82.4884968833, "6"],
[54.8817882667, 82.4881434333, "12"],
[54.8820450667, 82.4880255, "14"],
[54.8820399833, 82.4881601833, "13"],
[54.8817013833, 82.48815045, "11"],
[54.8814522333, 82.4882864667, "4"],
[54.88135345, 82.4881963833, "3"],
[54.89047955, 82.3660982833, "48"],
[54.8939863833, 82.3676102167, "84"],
[54.8908236333, 82.3668215167, "57"],
[54.8927242667, 82.3669994667, "72"],
[54.89707325, 82.3696241833, "111"],
[54.8951834, 82.3681841167, "96"],
[54.8891679333, 82.3661342, "25"],
[54.8990757167, 82.4813831667, "12"],
[54.8990598, 82.4826089667, "27"],
[54.8996862, 82.48382855, "34"],
[54.8998746167, 82.4868621833, "99"],
[54.9001283, 82.4864203833, "97"],
[54.9002882, 82.4875789833, "111"],
[54.9004845333, 82.4875032167, "113"],
[54.9005451667, 82.4877341667, "115"],
[54.8987095167, 82.48150085, "15"],
[54.8987892, 82.4817609, "17"],
[54.8991357, 82.48159105, "14"],
[54.89891375, 82.4808869667, "10"],
[54.8985199667, 82.4808965667, "11"],
[54.8985627833, 82.4811206333, "13"],
[54.8992842667, 82.4821156167, "18-20"],
[54.8988612333, 82.48195285, "19"],
[54.8993973833, 82.4824338, "22"],
[54.8989453833, 82.48216625, "23"],
[54.8994684833, 82.4826182833, "24"],
[54.8989983, 82.48239085, "25"],
[54.8995365667, 82.4828116833, "26"],
[54.8982566833, 82.4800233833, "1"],
[54.8995900333, 82.48303525, "28"],
[54.8991642833, 82.4829475167, "29"],
[54.8996510167, 82.4832267667, "30"],
[54.899284, 82.4832051333, "31"],
[54.8983305, 82.4802590667, "3"],
[54.8985982333, 82.4800186167, "2"],
[54.8995170333, 82.4845078667, "49"],
[54.8987404667, 82.4802334667, "4"],
[54.89943635, 82.4849588167, "77"],
[54.8983839667, 82.4804605, "5"],
[54.8987906833, 82.4804517, "6"],
[54.8997182, 82.4849414, "81"],
[54.8984425333, 82.4806757, "7"],
[54.8988546833, 82.4806650333, "8"],
[54.8982073167, 82.4808983833, "9"],
[54.9002304333, 82.4868039667, "101"],
[54.8997452667, 82.48737465, "103"],
[54.9001569667, 82.4873521333, "105A"],
[54.90035675, 82.4871693, "105"],
[54.89977645, 82.4853644833, "85"],
[54.8998911833, 82.4857328667, "93"],
[54.89830875, 82.4810073667, "11A"],
[54.8991998, 82.4818039833, "16"],
[54.9000736, 82.48765565, "109"],
[54.8998738833, 82.4877091, "107"],
[54.8584179167, 82.3917306, "28C"],
[54.8604560167, 82.3943771, "27"],
[54.8594062, 82.39328765, "22"],
[54.8602464667, 82.3945281333, "25"],
[54.8580738, 82.3913907167, "28B"],
[54.8588583833, 82.3948410167, "10"],
[54.8597253167, 82.3943257167, "20"],
[54.8594598667, 82.3949546667, "17"],
[54.85742675, 82.3934756833, "28D"],
[54.85779025, 82.3909575667, "28A"],
[54.8602461333, 82.39392145, "24"],
[54.8615513167, 82.3930931833, "30"],
[54.8615702833, 82.3936576333, "41"],
[54.8648762167, 82.391556, "85"],
[54.8669371833, 82.38969465, "116"],
[54.8656294833, 82.39053055, "96"],
[54.8627939333, 82.3928152833, "57"],
[54.8642163, 82.3938465167, "63B"],
[54.8633075167, 82.3925197167, "63A"],
[54.8752946833, 82.47600165, "16"],
[54.8752789, 82.4745710667, "26"],
[54.8752698667, 82.474182667, "30"],
[54.8752788833, 82.4747855667, "24"],
[54.8753729833, 82.4773013667, "4"],
[54.8752503333, 82.47339515, "36"],
[54.8753239, 82.4768918333, "8"],
[54.8752590667, 82.4736461333, "34"],
[54.8756213167, 82.4747827833, "25"],
[54.8752682333, 82.4738759333, "32"],
[54.8752943, 82.47621685, "14"],
[54.8755946667, 82.4783229167, "2"],
[54.8757436, 82.47737735, "7"],
[54.8758519, 82.4778569167, "3"],
[54.8756174833, 82.4745228, "27"],
[54.8756574833, 82.4762356, "15"],
[54.8756050833, 82.4734895, "33"],
[54.875302, 82.4766701833, "10"],
[54.8756027333, 82.4736947333, "31"],
[54.8752780667, 82.4758057, "18"],
[54.8757905833, 82.477583, "5"],
[54.8756395833, 82.4758414333, "19"],
[54.8756402, 82.4760084333, "17"],
[54.8752715833, 82.4751979, "20"],
[54.8757130167, 82.4771411333, "9"],
[54.8752756833, 82.47501635, "22"],
[54.87527695, 82.47433525, "28"],
[54.8756425833, 82.4752112667, "21"],
[54.8752937833, 82.4764377, "12"],
[54.87559675, 82.4732172, "35"],
[54.8753504333, 82.477108, "6"],
[54.8755737333, 82.4729657167, "37"],
[54.8756244333, 82.4743205667, "29"],
[54.8755172667, 82.4727099833, "39"],
[54.8756327333, 82.4750188, "23"],
[54.8754463333, 82.4724567833, "41"],
[54.8753804667, 82.4721916167, "43"],
[54.8753413, 82.4719123167, "45"],
[54.8751775167, 82.4728065, "40"],
[54.87523985, 82.4731198167, "38"],
[54.9129636333, 82.47354695, "15"],
[54.9129915667, 82.4741582833, "10"],
[54.9130924, 82.4741147667, "12"],
[54.91301345, 82.4738697833, "14"],
[54.9125089, 82.47363755, "3"],
[54.9126150667, 82.4743185833, "4"],
[54.9126618333, 82.4735482833, "5"],
[54.9125892, 82.47392305, "6"],
[54.9127883167, 82.47388245, "8"],
[54.9126731333, 82.473192, "7"],
[54.91275485, 82.47314795, "9"],
[54.9128106333, 82.4733799667, "11"],
[54.9123932, 82.4739944667, "2"],
[54.9123316833, 82.4737106167, "1"],
[54.9838611667, 82.5750239333, "209"],
[54.9690023333, 82.5700330333, "12"],
[54.9711171, 82.5702027833, "25"],
[54.9779899, 82.570433, "1/122"],
[54.97820695, 82.57005845, "2/122"],
[54.9800575, 82.5723918333, "153"],
[54.9811843, 82.5731835, "177"],
[54.9754233167, 82.57078555, "95"],
[54.8838929167, 82.4818853167, "12"],
[54.8837344667, 82.4818862, "14"],
[54.8835817667, 82.4818741, "16"],
[54.8834241, 82.4818550667, "18"],
[54.8832506167, 82.48183555, "20"],
[54.8830817667, 82.4818428833, "22"],
[54.8828965167, 82.48182015, "24"],
[54.8827122833, 82.4817928, "26"],
[54.8814133667, 82.4817274333, "44"],
[54.8813040833, 82.48171155, "46"],
[54.8810746667, 82.4817141833, "48"],
[54.8809023, 82.4816841, "50"],
[54.8807272167, 82.4816891167, "52"],
[54.8805686833, 82.4816589167, "54"],
[54.8803979167, 82.4816530833, "56"],
[54.8801843833, 82.48158535, "58"],
[54.8825403667, 82.4813836167, "32A"],
[54.88253505, 82.4817773, "32"],
[54.8825069167, 82.48115065, "34"],
[54.88240895, 82.4812873333, "36"],
[54.8823411, 82.4817443167, "38"],
[54.8822324, 82.4817659167, "40"],
[54.8852853, 82.4825293667, "1"],
[54.8852325667, 82.4820864167, "2"],
[54.8856616, 82.4830290667, "3"],
[54.8851546, 82.4819058667, "4"],
[54.8853310833, 82.4831131333, "5"],
[54.8851287833, 82.4816127333, "6"],
[54.8827869667, 82.4815392833, "26B"],
[54.88484925, 82.4820581167, "8"],
[54.9024855, 82.4814230667, "6"],
[54.9027508667, 82.48132635, "2"],
[54.90267385, 82.4810493833, "3"],
[54.902509, 82.4810477333, "4"],
[54.90239855, 82.4812007, "5"],
[54.8861399167, 82.4659005167, "2A"],
[54.8858972, 82.4701092167, "36"],
[54.8867484667, 82.4678494333, "19"],
[54.8861574833, 82.46575525, "2"],
[54.8864493167, 82.4662703167, "3"],
[54.88622685, 82.47015215, "39"],
[54.88624375, 82.4699778833, "37"],
[54.8863943167, 82.4703065667, "39A"],
[54.8858773667, 82.4704395333, "38"],
[54.8866652833, 82.4663845667, "3A"],
[54.8862623667, 82.4706270167, "41"],
[54.8856218833, 82.4704532333, "40"],
[54.8854065833, 82.4706356333, "42B"],
[54.88625425, 82.4707564167, "43"],
[54.88541165, 82.4704709667, "42A"],
[54.8861368333, 82.47271145, "55"],
[54.886122, 82.4661553833, "4"],
[54.8863355167, 82.4685020667, "27"],
[54.8865969667, 82.4687519167, "29A"],
[54.8865831, 82.4689422667, "31A"],
[54.8860333167, 82.46789315, "20"],
[54.8858932167, 82.4702396667, "36A"],
[54.88643745, 82.4660770167, "1"],
[54.8857492, 82.46868685, "30A"],
[54.8855154167, 82.4686515333, "30B"],
[54.8856861, 82.46828205, "24A"],
[54.8860060667, 82.4682543333, "24"],
[54.8863518833, 82.4681365167, "23"],
[54.8860244, 82.4680726833, "22"],
[54.8860988667, 82.4665564833, "10"],
[54.8863865333, 82.4673575, "11"],
[54.8863826833, 82.4675404, "13"],
[54.8863788667, 82.4677124167, "15"],
[54.8860585833, 82.4674608333, "14"],
[54.8856044667, 82.46749745, "16A"],
[54.8857502, 82.46754885, "16"],
[54.8864570833, 82.4677168333, "17"],
[54.8860457333, 82.4676692, "18"],
[54.8867451667, 82.4680089167, "19A"],
[54.8858168333, 82.4717908, "58"],
[54.8866057333, 82.4666266833, "5A"],
[54.8864473333, 82.4665519333, "5"],
[54.88573305, 82.4662191833, "6"],
[54.8861234333, 82.4729670667, "57"],
[54.8861040833, 82.4732588, "59"],
[54.8857812833, 82.4727290333, "62"],
[54.8860733167, 82.47367975, "63"],
[54.8853214167, 82.47302445, "64A"],
[54.8857647, 82.4729568833, "64"],
[54.8860630667, 82.4741376333, "65"],
[54.8855514167, 82.4731432833, "66A"],
[54.8857605333, 82.4732639667, "66"],
[54.88604615, 82.4744234333, "67"],
[54.8857253333, 82.4734757667, "68"],
[54.8860271667, 82.4749003, "71"],
[54.8864273833, 82.4668194167, "7"],
[54.8861134167, 82.4663483833, "8"],
[54.88530955, 82.4734951667, "72A"],
[54.8853649167, 82.4735031333, "72"],
[54.8857145667, 82.47370235, "74"],
[54.88570935, 82.4738793833, "76"],
[54.8856962833, 82.4740871833, "78"],
[54.8855425, 82.4740492667, "80"],
[54.8855359667, 82.47421665, "82"],
[54.8856920333, 82.4742632667, "84"],
[54.88567285, 82.4743871833, "86"],
[54.8856348, 82.47498665, "88"],
[54.8864008667, 82.4671270833, "9"],
[54.8859601833, 82.47522375, "73"],
[54.8859930167, 82.4754003167, "75"],
[54.88563045, 82.4752063667, "90"],
[54.8856196667, 82.4754834167, "94"],
[54.8855985333, 82.4757720333, "98"],
[54.8852094333, 82.4756059333, "96"],
[54.8856225333, 82.4706336667, "44"],
[54.8863443167, 82.4711711167, "45A"],
[54.8862241333, 82.47112885, "45"],
[54.8858591, 82.4707636333, "46"],
[54.8862151, 82.4713376833, "47"],
[54.88584785, 82.4710055, "48"],
[54.8863784667, 82.4716221167, "49A"],
[54.88619305, 82.4716161667, "49"],
[54.8854010167, 82.4710779333, "50A"],
[54.8855194, 82.4710888, "50"],
[54.8861586167, 82.4718484, "51"],
[54.8855134333, 82.4712143833, "52"],
[54.8858417833, 82.4713232833, "54"],
[54.8858254, 82.4715816333, "56"],
[54.8859913, 82.4685190667, "28"],
[54.8863223167, 82.4686848833, "29"],
[54.8859773333, 82.46879095, "30"],
[54.8863225167, 82.4688814167, "31"],
[54.8859628333, 82.4690224667, "32"],
[54.8863278333, 82.4690195667, "33"],
[54.8860351333, 82.4746824, "69"],
[54.88563915, 82.4684005167, "26"],
[54.8863489, 82.4683084, "25"],
[54.8866069, 82.4673016, "11A"],
[54.8868120167, 82.4673208833, "11B"],
[54.88578115, 82.4680634667, "22A"],
[54.8863727, 82.4679364, "21"],
[54.8858363, 82.4659994, "4A"],
[54.88658795, 82.4674919167, "13A"],
[54.92234345, 82.4747052, "199"],
[54.92177305, 82.4769218333, "2"],
[54.9221347833, 82.47694995, "1"],
[54.9222941667, 82.47512075, "165"],
[54.9219244667, 82.4755311667, "126"],
[54.92194885, 82.4751084333, "164"],
[54.92227225, 82.4756573333, "109"],
[54.9226473833, 82.47590455, "105"],
[54.9217738833, 82.4766539667, "38"],
[54.9226126333, 82.4765605333, "45"],
[54.9221432333, 82.4762786, "51"],
[54.92185925, 82.4759778667, "80"],
[54.9219880167, 82.4744712833, "230"],
[54.9213271, 82.4744695667, "200"],
[54.9210363333, 82.4743909167, "210"],
[54.9206876333, 82.4744863, "220"],
[54.9212772667, 82.4748825167, "184"],
[54.9213329, 82.4754072167, "194"],
[54.92179965, 82.4763127667, "50"],
[54.9226488667, 82.4760626667, "101"],
[54.9224377167, 82.4742912, "231"],
[54.9222663833, 82.4741209667, "253"],
[54.9220891, 82.4742094833, "250"],
[54.8763709833, 82.4737251167, "6"],
[54.8762928, 82.4740830833, "7"],
[54.8757872, 82.47372185, "2"],
[54.8759274833, 82.4737143667, "4"],
[54.8761889833, 82.4744309833, "5B"],
[54.8760917667, 82.4744256833, "5A"],
[54.8760035, 82.47408515, "3"],
[54.8758006, 82.4741481167, "1"],
[54.8945807833, 82.4731283, "92"],
[54.8952838, 82.4659743667, "9"],
[54.8945913667, 82.47286075, "88"],
[54.8948307167, 82.4678840833, "26"],
[54.8946495333, 82.4715883833, "68"],
[54.8955784167, 82.4666195833, "17"],
[54.8950308833, 82.4707890333, "55"],
[54.8950268333, 82.4708643, "57"],
[54.8950210333, 82.4709645333, "59"],
[54.8950726167, 82.4692980667, "35"],
[54.8948167167, 82.4681206667, "28"],
[54.89480715, 82.4683576167, "30"],
[54.89448235, 82.47392275, "100"],
[54.8949025833, 82.4736886667, "101"],
[54.8944604833, 82.4740989333, "102"],
[54.8940345667, 82.4741795333, "104"],
[54.8948037, 82.4748156667, "105"],
[54.8944383833, 82.4744140333, "106"],
[54.8949698833, 82.4659329667, "10"],
[54.8949612167, 82.4663892333, "12"],
[54.8949153, 82.46660965, "14"],
[54.8948991667, 82.46678365, "16"],
[54.8947661, 82.46694865, "18A"],
[54.8944432333, 82.4669301, "18B"],
[54.8948852, 82.4669605667, "18"],
[54.8948780167, 82.46712785, "20"],
[54.8944023, 82.4672810833, "22B"],
[54.8947610167, 82.46729965, "22A"],
[54.8948679667, 82.46733215, "22"],
[54.8948783833, 82.46748345, "1/24-7/24"],
[54.8947230167, 82.4702766667, "42"],
[54.8946909667, 82.4707959333, "54"],
[54.8946726833, 82.4711023333, "60"],
[54.8946703833, 82.4712066833, "62"],
[54.8946656, 82.4712626667, "64"],
[54.8949888833, 82.4656431, "6"],
[54.8949382, 82.4729810833, "93"],
[54.8945739333, 82.47341895, "94"],
[54.8949277, 82.4731673, "95"],
[54.89438165, 82.4736724333, "96A"],
[54.8945503667, 82.4736765833, "96"],
[54.8949105333, 82.47340155, "97A"],
[54.8942335833, 82.4737639667, "98"],
[54.8946295667, 82.4718361, "72"],
[54.89462675, 82.4719766167, "74"],
[54.8949939167, 82.4719069333, "77"],
[54.8946185167, 82.4722803667, "82"],
[54.8949549, 82.4725255167, "87"],
[54.8949826333, 82.4657729, "8"],
[54.8952739667, 82.4662657333, "11"],
[54.8954714167, 82.4664023833, "13A"],
[54.8955781667, 82.46640275, "13B"],
[54.8952808167, 82.4663722, "13"],
[54.89527365, 82.4665192833, "15"],
[54.8956551167, 82.4661953667, "11B"],
[54.8953330833, 82.4650771, "1"],
[54.8950785667, 82.469182167, "33"],
[54.8950110333, 82.4654238667, "2"],
[54.8950599167, 82.4704818, "45"],
[54.8950526167, 82.4705562667, "47"],
[54.8950517333, 82.4706304167, "49"],
[54.8950748667, 82.4694276667, "41"],
[54.8953314667, 82.4653118333, "3"],
[54.8950057833, 82.46551395, "4"],
[54.8950353, 82.4734756833, "97"],
[54.8950013, 82.4717792, "75"],
[54.8950426833, 82.4706778167, "51"],
[54.89503905, 82.4707278833, "53"],
[54.8950147333, 82.4710415167, "61"],
[54.8950166833, 82.4711306, "63"],
[54.8950141, 82.4712134833, "65"],
[54.8950130833, 82.4712694167, "67"],
[54.8950105, 82.4713271, "69"],
[54.8950101667, 82.4713877667, "71"],
[54.8950061333, 82.4714993167, "73"],
[54.8953044, 82.4655703333, "5"],
[54.8953043, 82.4657896167, "7"],
[54.8948314667, 82.46896985, "36"],
[54.8944233667, 82.4670945167, "20B"],
[54.89476705, 82.4671119, "20A"],
[54.8948155167, 82.46873695, "34"],
[54.8785435, 82.4391193, "108"],
[54.85482825, 82.43943885, "372"],
[54.8843674667, 82.44077705, "44"],
[54.8514708333, 82.44301855, "414"],
[54.8786210833, 82.4386722333, "107"],
[54.8536346167, 82.43854, "2/377"],
[54.88482555, 82.43861845, "37"],
[54.85393405, 82.4384665833, "1/377"],
[54.87792065, 82.43870995, "115"],
[54.8616766, 82.43942835, "296"],
[54.8758269167, 82.439114, "136"],
[54.8611102167, 82.4393358, "302"],
[54.8630311167, 82.4365396167, "279"],
[54.8653560833, 82.4373495833, "253"],
[54.8757949833, 82.4386379333, "137"],
[54.8786179833, 82.4342996333, "2/105"],
[54.8874004, 82.4391212667, "1/10-2/10"],
[54.8447363167, 82.43930545, "482"],
[54.88403545, 82.4386151333, "45"],
[54.8717442667, 82.4349390667, "183"],
[54.8767875333, 82.4386578667, "127"],
[54.8797060833, 82.4386293833, "93"],
[54.8866638167, 82.4390628, "18"],
[54.8791973, 82.4386315, "97"],
[54.88585575, 82.4362985167, "19"],
[54.8790987667, 82.4391399833, "100"],
[54.8771662, 82.43926595, "124"],
[54.8838361, 82.4391195833, "48"],
[54.8857025667, 82.4423457333, "30"],
[54.8854774667, 82.4423092, "3/30"],
[54.8449495333, 82.43932215, "480"],
[54.8540070333, 82.4394581833, "376"],
[54.8831838833, 82.4385145, "55"],
[54.8588749833, 82.4393561333, "326"],
[54.86279375, 82.4385341667, "281"],
[54.8445601333, 82.43930445, "484"],
[54.84437095, 82.43930065, "486"],
[54.8788133833, 82.4351573667, "1/105"],
[54.8800643333, 82.4356186, "1/93"],
[54.87918835, 82.4355875333, "2/93"],
[54.88086735, 82.4358693833, "83"],
[54.88697085, 82.4385406333, "15"],
[54.8505857167, 82.4386953333, "425"],
[54.8857656333, 82.4386266333, "21"],
[54.8517299333, 82.43952155, "404"],
[54.8859354667, 82.4391316833, "20"],
[54.8643110167, 82.43852915, "269"],
[54.8638944167, 82.4352222, "271"],
[54.8629044167, 82.4394276667, "280"],
[54.8636698333, 82.4384519167, "273"],
[54.87065885, 82.4387204333, "197"],
[54.870552, 82.4392104333, "198"],
[54.86847865, 82.4362560333, "215"],
[54.8682894833, 82.4387331667, "221"],
[54.8723437333, 82.4386659167, "179"],
[54.8713473833, 82.4386830333, "191"],
[54.8803684, 82.4391223, "84"],
[54.8801818167, 82.4386532333, "89"],
[54.8795138833, 82.4391232667, "98"],
[54.88233015, 82.4385688167, "67"],
[54.8822730833, 82.439127, "68"],
[54.8815140333, 82.4385229167, "75"],
[54.88161725, 82.43921275, "76"],
[54.88298115, 82.4391210167, "60"],
[54.88356985, 82.44183935, "54"],
[54.88688885, 82.4390723333, "16"],
[54.8854630667, 82.44062525, "1/30"],
[54.8857315833, 82.4406345667, "2/30"],
[54.8850814333, 82.4391024667, "32"],
[54.85615335, 82.4394051333, "358"],
[54.8484322833, 82.4386304333, "451"],
[54.849595, 82.4395278833, "438"],
[54.8685579333, 82.43929385, "222"],
[54.8673376667, 82.4387301333, "231"],
[54.8672263, 82.4391822833, "234"],
[54.8658104, 82.4384541833, "249"],
[54.8650818333, 82.4384285833, "257"],
[54.8572850833, 82.4388435667, "345"],
[54.8695889833, 82.4385987333, "207"],
[54.8444514833, 82.4388799167, "483"],
[54.8828889333, 82.4356993, "51"],
[54.8832340833, 82.4358504, "1/51"],
[54.8573635, 82.4392901833, "342"],
[54.86163445, 82.43881845, "295"],
[54.8624819833, 82.438809, "287"],
[54.84347995, 82.4385449833, "495"],
[54.85704685, 82.4422632333, "346"],
[54.8881785167, 82.4536787833, "11"],
[54.8876931833, 82.4532197833, "5"],
[54.887782833, 82.4536870667, "7"],
[54.8883681, 82.4535562333, "2/10"],
[54.88862675, 82.4537201667, "4/10"],
[54.88857235, 82.4536184167, "3/10"],
[54.88834935, 82.45339255, "1/10"],
[54.8880737833, 82.4534382833, "9"],
[54.88862905, 82.4582377167, "8"],
[54.888388, 82.4577553167, "5A"],
[54.8890413167, 82.4584074, "10A"],
[54.8890455167, 82.45818135, "10"],
[54.8893714, 82.4579083667, "1"],
[54.8891550333, 82.4579009333, "2"],
[54.8889156, 82.45789245, "3"],
[54.8887209667, 82.4578687833, "4"],
[54.8885121, 82.45785425, "5"],
[54.8884355167, 82.4579579333, "6"],
[54.8884670667, 82.4581608667, "7"],
[54.88885115, 82.4581993167, "9"],
[54.88829695, 82.4581456, "7A"],
[54.89493095, 82.50293945, "2/207"],
[54.8939846833, 82.4919359167, "1/143"],
[54.9326599333, 82.5720857333, "946"],
[54.8940428667, 82.4929087, "2/143"],
[54.93985015, 82.5776648, "1006"],
[54.9234984333, 82.5621109333, "816"],
[54.9374057, 82.57533755, "1004"],
[54.92045495, 82.5594362667, "773"],
[54.9370037333, 82.5752245333, "1002"],
[54.9233134, 82.5619061667, "814"],
[54.9247701333, 82.5642938333, "838"],
[54.9091874667, 82.5318147333, "504"],
[54.90968075, 82.53436585, "525"],
[54.9100798667, 82.53351915, "518"],
[54.9137304333, 82.5349179, "560"],
[54.9131590333, 82.53488155, "558"],
[54.9072097667, 82.5257719, "458"],
[54.89594205, 82.4996267667, "178"],
[54.9372702, 82.57594035, "1013"],
[54.89638255, 82.5065894833, "246"],
[54.8968645833, 82.50876055, "259"],
[54.8980340833, 82.5096747833, "276"],
[54.8986749667, 82.5105449167, "280"],
[54.89924075, 82.5129982667, "295"],
[54.9015737, 82.515433, "324"],
[54.91571275, 82.5534373, "705"],
[54.9162442833, 82.5534827, "706"],
[54.9148016833, 82.54767885, "648"],
[54.9148501, 82.5499118333, "673"],
[54.9151485667, 82.5495203167, "660"],
[54.9197264, 82.5575957333, "748"],
[54.9212959167, 82.5604435167, "787"],
[54.9255722167, 82.5660694167, "852"],
[54.9026268333, 82.5172354667, "356"],
[54.8950368333, 82.5025268833, "1/207"],
[54.9122779833, 82.5393717167, "2/573"],
[54.9114679667, 82.5398593333, "3/573"],
[54.91540075, 82.5527015167, "699"],
[54.9012012167, 82.51619825, "335"],
[54.9168711667, 82.5553676, "719"],
[54.982395667, 82.5561893167, "723"],
[54.9180392833, 82.5566833, "739"],
[54.9130946167, 82.5474586167, "637"],
[54.8940036333, 82.4831404833, "29"],
[54.8943207667, 82.4865820833, "69"],
[54.8943952833, 82.4886118, "71"],
[54.8951511833, 82.4905976667, "112"],
[54.90356905, 82.5202661333, "379"],
[54.9042539, 82.5213877833, "391"],
[54.9058724667, 82.5242790667, "427"],
[54.9355250333, 82.57499645, "987"],
[54.9134563333, 82.5426692667, "603"],
[54.9135913667, 82.54315755, "607"],
[54.91401355, 82.5428852833, "608"],
[54.9106131167, 82.5359661167, "539"],
[54.9111353167, 82.53571595, "542"],
[54.9113920167, 82.5360293167, "546"],
[54.9121793167, 82.5377621, "568"],
[54.9346634, 82.5743922333, "979"],
[54.9374423833, 82.5674758833, "972"],
[54.9156359, 82.55118655, "692"],
[54.9155415167, 82.5508029, "690"],
[54.90281625, 82.51905675, "373"],
[54.9027791333, 82.582252833, "358"],
[54.8958690833, 82.5018481167, "190"],
[54.9789857333, 82.4405075667, "168"],
[54.9695422, 82.4324544167, "23"],
[54.9694634, 82.4313197333, "12"],
[54.9734056167, 82.4391843667, "105"],
[54.9748037833, 82.4419470833, "123"],
[54.9775236, 82.4415263333, "155"],
[54.9782757667, 82.44079755, "166"],
[54.9718126167, 82.4347789833, "54"],
[54.8974829, 82.4523839667, "11"],
[54.896949, 82.4538974333, "10"],
[54.8973599167, 82.4533428167, "3"],
[54.89717915, 82.4544804167, "4"],
[54.8973309833, 82.45308765, "5"],
[54.8972213833, 82.4542655167, "6"],
[54.8972975167, 82.452858, "7"],
[54.8971736167, 82.4540106333, "8"],
[54.8972301333, 82.4525011667, "9"],
[54.8962831, 82.4514132833, "40"],
[54.8962904167, 82.4509267333, "42"],
[54.8964889167, 82.4515006167, "44"],
[54.8966648, 82.4514576667, "46"],
[54.8963241333, 82.4516917333, "38"],
[54.8971486, 82.4537583167, "12"],
[54.8974914833, 82.4522686333, "13"],
[54.8968280167, 82.4517962167, "32"],
[54.8965602833, 82.4518541, "34"],
[54.8963553, 82.4518366333, "36"],
[54.8972173667, 82.4551419333, "2"],
[54.8970665667, 82.45323925, "14"],
[54.8971966, 82.4522688167, "15"],
[54.8968064, 82.4532278167, "16"],
[54.8967456833, 82.4531232333, "18"],
[54.8974595167, 82.4539856833, "1"],
[54.89702105, 82.4529966167, "20"],
[54.89697325, 82.4525840667, "22"],
[54.8966754833, 82.45262025, "24"],
[54.8965024, 82.4525581333, "26"],
[54.8967277167, 82.4524711167, "28"],
[54.8969411167, 82.4523854, "30"],
[54.8971252667, 82.4517190167, "17"],
[54.8973954333, 82.4516434667, "19"],
[54.89734885, 82.4512056667, "27"],
[54.8975603333, 82.4513639167, "23"],
[54.8975662667, 82.45155165, "21"],
[54.89758735, 82.45118755, "25"],
[54.8976514, 82.4505551833, "25A"],
[54.93618265, 82.4679452833, "99"],
[54.9364427, 82.47434405, "47"],
[54.93602995, 82.4635648833, "143"],
[54.9363754167, 82.4732709667, "55"],
[54.9364611, 82.47575415, "37"],
[54.9362570167, 82.4694700833, "89"],
[54.9356639667, 82.4542221333, "225"],
[54.9365317333, 82.4564987833, "201"],
[54.9357644333, 82.45652615, "1/201"],
[54.9356391667, 82.4555529667, "209"],
[54.9359229, 82.4614506167, "157"],
[54.9354519, 82.4510958, "245"],
[54.8043647667, 82.3646767, "9"],
[54.8033645333, 82.3644417333, "14"],
[54.8041373, 82.3641572833, "11"],
[54.9559902833, 82.4358548667, "1/3116"],
[54.9541933, 82.43567675, "3126"],
[54.9159823833, 82.4458315667, "2/3627"],
[54.91406535, 82.4497318167, "3668"],
[54.9555601667, 82.4360378833, "2/3116"],
[54.9139425833, 82.4497730667, "3666"],
[54.9160902, 82.4453786667, "1/3627"],
[54.9619189333, 82.4331309167, "3032"],
[54.9609963833, 82.4328218833, "3039"],
[54.9616219333, 82.4333006833, "3036"],
[54.9329983333, 82.4291615333, "3361"],
[54.9152040667, 82.4487561167, "3654"],
[54.9319928333, 82.430282167, "3384"],
[54.91578065, 82.4478569, "3642"],
[54.9157454833, 82.4465326333, "3635"],
[54.9151056, 82.4479749833, "3643"],
[54.91545865, 82.4473662167, "3639"],
[54.9155843167, 82.4470310167, "3637"],
[54.9027715667, 82.45210165, "3794"],
[54.9032760833, 82.4549883, "3784"],
[54.9748930833, 82.4242103667, "2855"],
[54.9773033833, 82.42065365, "2829"],
[54.9444458667, 82.4188207667, "3217"],
[54.9012992833, 82.4500824333, "3807"],
[54.9127339333, 82.4503371, "3682"],
[54.90071495, 82.4536467833, "3829"],
[54.9048702167, 82.45171675, "2/3774"],
[54.9001265, 82.4627736833, "3910"],
[54.8984810667, 82.4580702, "2/3879"],
[54.8987156833, 82.45782225, "3/3879"],
[54.8996284833, 82.4598028333, "3886"],
[54.91662675, 82.4488524167, "3648"],
[54.9105417167, 82.4505777, "3714"],
[54.9047285333, 82.458219, "1/3774"],
[54.98387015, 82.4128784667, "2/2724"],
[54.9836752333, 82.4125610667, "1/2724"],
[54.8997874, 82.4596524, "2/3886"],
[54.8999206167, 82.4595150667, "3/3886"],
[54.9052384833, 82.4516238333, "3/3774"],
[54.9009602667, 82.4546291667, "3846"],
[54.89997485, 82.4588545167, "3890"],
[54.9160101833, 82.4469321333, "3636"],
[54.9504464333, 82.43548145, "3164"],
[54.90139465, 82.4518174, "3808"],
[54.9003306333, 82.4547485333, "3831"],
[54.9150642, 82.4457459, "3631"],
[54.9700292833, 82.4302066, "2954"],
[54.9719347833, 82.4284579333, "2920"],
[54.9684611833, 82.4302354667, "2959"],
[54.9638249667, 82.4310026333, "3011"],
[54.9635499667, 82.4311723667, "3013"],
[54.9621262833, 82.4321201167, "3025"],
[54.9599553667, 82.4336584667, "3059"],
[54.9593913167, 82.4346581667, "3072"],
[54.9671775, 82.4315904833, "2978"],
[54.9654828167, 82.4323972833, "2996"],
[54.9304655333, 82.4298457167, "3403"],
[54.9397400667, 82.4320840667, "3292"],
[54.9397871333, 82.4311546, "3299"],
[54.93902, 82.4299714, "3301"],
[54.93884655, 82.4297564667, "3311"],
[54.9378664, 82.42977575, "3320"],
[54.9375432, 82.42891805, "3321"],
[54.9370408, 82.4289005833, "3331"],
[54.9364621167, 82.4289989833, "3337"],
[54.9358432667, 82.4290959667, "3339"],
[54.95477045, 82.4310178833, "3103"],
[54.9508932667, 82.4345944, "3163"],
[54.9502843833, 82.4345016333, "3169"],
[54.9476339333, 82.4348761333, "1/3200"],
[54.9459382167, 82.4300649167, "3215"],
[54.9294075333, 82.4304862, "3414"],
[54.9292768667, 82.4300710167, "3415"],
[54.9481910333, 82.43494365, "2/3200"],
[54.9276201333, 82.4302237167, "3433"],
[54.9263022167, 82.4323864333, "3456"],
[54.9577552167, 82.43514095, "3090"],
[54.9559199, 82.4356498167, "3110"],
[54.9556312, 82.4352157667, "3111"],
[54.9541667833, 82.4350528333, "3127"],
[54.924353, 82.43477375, "3488"],
[54.92140285, 82.4361990333, "3521"],
[54.9216205, 82.4367220333, "3522"],
[54.9199150167, 82.4372039667, "3537"],
[54.9191848333, 82.4377457167, "3553"],
[54.91800785, 82.4398907667, "3571"],
[54.982554, 82.4427753167, "3596"],
[54.9167918667, 82.4434860333, "3611"],
[54.9154718333, 82.4484893833, "3650"],
[54.91254, 82.4489284667, "3693"],
[54.9096463167, 82.4500162167, "3715"],
[54.9095109, 82.45076725, "3718"],
[54.90312135, 82.4513793, "3791"],
[54.9025248833, 82.4514848833, "3797"],
[54.9027026, 82.4521118333, "3796"],
[54.9012756, 82.4523393333, "3809"],
[54.9000247833, 82.4550734667, "3847"],
[54.8996109167, 82.45623955, "3853"],
[54.8990466, 82.4570460167, "3861"],
[54.8982341833, 82.4584695333, "1/3879"],
[54.9037354333, 82.4513122, "3783"],
[54.9164707667, 82.4457016833, "3626"],
[54.9005404, 82.4554475167, "3838"],
[54.92350345, 82.4354481833, "3498"],
[54.92093435, 82.4372154, "3528"],
[54.9733884167, 82.4270654167, "2900"],
[54.9735011833, 82.426221, "2883"],
[54.9737880333, 82.4258421667, "2881"],
[54.9736479167, 82.4268099667, "2882"],
[54.8857180167, 82.4319128667, "1/1699"],
[54.8762356, 82.4124507167, "1498"],
[54.8760383833, 82.4119469333, "1494"],
[54.8881260667, 82.4328696, "2/1715"],
[54.8866376, 82.4333463667, "1/1715"],
[54.8884282, 82.4323350167, "1714"],
[54.8881726667, 82.44522875, "1835A"],
[54.8828618833, 82.42668015, "1643"],
[54.8875062667, 82.4321305667, "1713"],
[54.8891637, 82.4487508333, "1863"],
[54.8890458667, 82.4450934833, "1835"],
[54.8893503667, 82.4505826167, "1881"],
[54.8892833167, 82.4493800333, "1871"],
[54.88967995, 82.44903065, "1866"],
[54.8897650833, 82.45173775, "1894"],
[54.88972655, 82.4509517833, "1886"],
[54.8893972, 82.4519753167, "1895"],
[54.8893728833, 82.4515209833, "1891"],
[54.8893832667, 82.458283333, "1893"],
[54.88975065, 82.4512729833, "1888"],
[54.8897555167, 82.4524542333, "1896"],
[54.8789651833, 82.4203288667, "1567"],
[54.8891086, 82.4330816833, "1716"],
[54.8749076, 82.4095179667, "1466"],
[54.8766546833, 82.41371075, "1510"],
[54.87762145, 82.4159128833, "1532"],
[54.8778396333, 82.41638935, "1534"],
[54.8784475833, 82.482476, "1544"],
[54.8789228667, 82.4189449833, "1560"],
[54.8838774833, 82.4277925667, "1659"],
[54.8865829, 82.4310726667, "2/1699"],
[54.8869873, 82.4315526833, "1705"],
[54.8887145167, 82.4342103167, "1735"],
[54.8886082667, 82.4386434, "1786"],
[54.8888977833, 82.4397067833, "1788"],
[54.8889447833, 82.4399386, "1790"],
[54.8891184, 82.4403393, "1800"],
[54.8886052167, 82.44114285, "1811"],
[54.8890688833, 82.4442045667, "1829"],
[54.8894286667, 82.4442416167, "1830"],
[54.8894495167, 82.4447870333, "1832"],
[54.8894350833, 82.4526888167, "1903"],
[54.8898216167, 82.45284305, "1902"],
[54.8898244333, 82.45305355, "1906"],
[54.8895077667, 82.4534430333, "1907"],
[54.8895153, 82.4539427833, "1913"],
[54.8820731, 82.4246370667, "1/1628"],
[54.8829790333, 82.42515415, "2/1628"],
[54.8829182333, 82.42331235, "3/1628"],
[54.8846927167, 82.4287510833, "1669"],
[54.8857990667, 82.4293535333, "1682"],
[54.8859693167, 82.4303029167, "1/1689"],
[54.8861213333, 82.4304782, "1689"],
[54.9054227833, 82.4822613, "5"],
[54.90567515, 82.4819121167, "6"],
[54.9058446667, 82.4825176167, "10"],
[54.9057151167, 82.4832514, "11"],
[54.9059177, 82.4827449333, "12"],
[54.9062382833, 82.48278225, "14"],
[54.9059932667, 82.4830166333, "16"],
[54.90537935, 82.4821119, "3"],
[54.9055974, 82.4816880167, "4"],
[54.9055800167, 82.4827762667, "7"],
[54.9053443333, 82.4819134167, "1"],
[54.9056483167, 82.4830068333, "9"],
[54.9687541667, 82.5740302667, "1149"],
[54.9203192833, 82.5148173833, "4/319"],
[54.9566814833, 82.5624372, "1/978"],
[54.95688745, 82.5621776167, "2/978"],
[54.9580920167, 82.5647472333, "995"],
[54.92775475, 82.5378236667, "2/568"],
[54.92609085, 82.5347061333, "1/542"],
[54.9266186167, 82.5349056333, "2/542"],
[54.9269626167, 82.5353566167, "3/542"],
[54.9208396833, 82.5299344667, "422"],
[54.9207653333, 82.5242669667, "387"],
[54.9178039333, 82.49454775, "140"],
[54.9456599, 82.5548334167, "2/836"],
[54.9455115167, 82.5542481167, "1/836"],
[54.9194724833, 82.5061424833, "238"],
[54.9193864333, 82.5055969833, "232"],
[54.982102167, 82.49730755, "159"],
[54.9307227667, 82.53812715, "1/618-10/618"],
[54.9369806, 82.5416204833, "648A"],
[54.93400485, 82.5405088167, "648"],
[54.9352812167, 82.5418752167, "656"],
[54.9261541333, 82.5367970667, "564"],
[54.9276279, 82.5381303167, "1/568"],
[54.9461318333, 82.5545134167, "842"],
[54.94315595, 82.5537148, "806"],
[54.9464287167, 82.5549129667, "844"],
[54.9713060833, 82.57780675, "1198"],
[54.9403528, 82.5492173333, "748"],
[54.9406445667, 82.5496667833, "1/750"],
[54.9282707, 82.5363209167, "7/568"],
[54.9188207333, 82.505113, "225"],
[54.9388163333, 82.5467693, "714"],
[54.9405476, 82.5503991667, "749"],
[54.94102555, 82.55021985, "750"],
[54.94425745, 82.5552436333, "819"],
[54.9459448333, 82.55501645, "838"],
[54.9465835833, 82.5559441, "845"],
[54.9472323167, 82.5550552833, "850"],
[54.9479511833, 82.5562512667, "1/861"],
[54.9481898667, 82.55635715, "2/861"],
[54.9500993333, 82.5559819167, "888"],
[54.95089095, 82.5580154, "899"],
[54.9289862833, 82.5364012833, "6/568"],
[54.9653755, 82.5702818667, "1099"],
[54.9299398667, 82.5377803667, "3/610"],
[54.9297131333, 82.5382649, "2/610"],
[54.92950415, 82.5389677333, "1/610"],
[54.9285464333, 82.53936505, "601"],
[54.92981565, 82.5365770833, "568"],
[54.9335473333, 82.5403341667, "646"],
[54.9331034167, 82.5400956, "642"],
[54.9327759167, 82.538732, "640"],
[54.9334526333, 82.5387036667, "638"],
[54.93320675, 82.5383744833, "636"],
[54.9336129167, 82.5375626, "634"],
[54.93288865, 82.5381226667, "632"],
[54.9327198833, 82.53720065, "630"],
[54.93255565, 82.53790585, "628"],
[54.93178035, 82.5394509333, "626"],
[54.9186410667, 82.5002110833, "182"],
[54.9172343667, 82.4951996667, "139"],
[54.9180053667, 82.5002946167, "183"],
[54.9174022167, 82.4964858167, "151"],
[54.9234301333, 82.5355513833, "516"],
[54.9434775667, 82.5532109833, "808"],
[54.93984305, 82.5484721667, "742"],
[54.9705266833, 82.57732895, "182"],
[54.9272626167, 82.53717615, "3/568"],
[54.9532905667, 82.5580751833, "926"],
[54.9528798333, 82.5576940667, "924"],
[54.9659760333, 82.5710443833, "1/1111"],
[54.9396966667, 82.5481831, "740"],
[54.9128371, 82.4832793167, "19"],
[54.9140123833, 82.4838446333, "26"],
[54.9172423167, 82.4912675833, "106"],
[54.91736885, 82.4918037833, "110"],
[54.9824985, 82.4930980167, "120"],
[54.9169178833, 82.4926386, "121"],
[54.9163286667, 82.4889877833, "85"],
[54.9169649167, 82.4891728833, "86"],
[54.9165898167, 82.4905852833, "97"],
[54.9139972667, 82.4850735, "37"],
[54.9158482667, 82.48707945, "68"],
[54.9195504667, 82.5065384833, "240"],
[54.9197355333, 82.5077362, "256"],
[54.9187252667, 82.5091617167, "263"],
[54.9196476833, 82.5108055333, "277"],
[54.9202849333, 82.5111623667, "300"],
[54.9206995667, 82.5135292833, "1/314"],
[54.9207361, 82.5138259667, "2/314"],
[54.9562101, 82.5616106, "972"],
[54.9204318667, 82.5155629167, "1/319"],
[54.9203768167, 82.5151516333, "2/319"],
[54.91788475, 82.51599185, "3/319"],
[54.9208983667, 82.5150343667, "322"],
[54.9207446167, 82.5174052333, "355"],
[54.9213706667, 82.5182903833, "364"],
[54.9209673667, 82.5228385667, "381"],
[54.9121427, 82.48111095, "1"],
[54.9210744167, 82.526721, "398"],
[54.92060065, 82.5267811333, "421"],
[54.9203042167, 82.53031625, "441"],
[54.9205438667, 82.5322192667, "472"],
[54.95440025, 82.5603198167, "949"],
[54.9549745833, 82.5610077, "955"],
[54.9557622833, 82.5620862333, "971"],
[54.95699575, 82.56162575, "976"],
[54.96071475, 82.5671597833, "1043"],
[54.95945125, 82.5654647667, "1048"],
[54.9618459333, 82.56799375, "1/1049"],
[54.9616152833, 82.5678077833, "2/1049"],
[54.9661303667, 82.5708020833, "2/1111"],
[54.9667493333, 82.57131025, "1115"],
[54.96711415, 82.5715806667, "1117"],
[54.9675804833, 82.5719935, "1121"],
[54.9684296167, 82.5727105333, "1133"],
[54.9470393333, 82.5592361, "859"],
[54.91908795, 82.5034454, "1/222"],
[54.9190107333, 82.5030951833, "2/222"],
[54.9182063667, 82.4975724833, "162"],
[54.9215276333, 82.5398657167, "338"],
[54.9214903, 82.5403513167, "347"],
[54.9192073833, 82.5385113667, "60"],
[54.9194124167, 82.53863005, "70"],
[54.9202965333, 82.5390272333, "170"],
[54.9202201333, 82.5394256333, "187"],
[54.9200427667, 82.5393355, "165"],
[54.9196745333, 82.5387265333, "110"],
[54.9196443833, 82.5391287333, "113"],
[54.9200210333, 82.5388776, "148"],
[54.9198508167, 82.5392385667, "139"],
[54.9198443833, 82.53880195, "130"],
[54.92078415, 82.5393372, "240"],
[54.9203728, 82.5395211833, "205"],
[54.92054995, 82.5391807, "218"],
[54.9207016833, 82.53928345, "222"],
[54.9204983167, 82.5396219333, "225"],
[54.9206377, 82.5392380167, "220"],
[54.9209028833, 82.53941765, "1/258"],
[54.9206256667, 82.5397483667, "243"],
[54.92098855, 82.5394799, "2/258"],
[54.9211211, 82.54010905, "303"],
[54.9207808, 82.5398586, "261"],
[54.9209433167, 82.5399736333, "285"],
[54.9210710833, 82.53953355, "3/258"],
[54.9213220667, 82.54020665, "325"],
[54.9213740167, 82.5397642, "320"],
[54.9216746167, 82.5399703333, "356"],
[54.9217735667, 82.5401128333, "370"],
[54.9216458, 82.5405448833, "373"],
[54.92187255, 82.54025525, "386"],
[54.9219284333, 82.5408441667, "401"],
[54.9103304833, 82.4721328333, "10"],
[54.9102787167, 82.4719914, "11"],
[54.9108774833, 82.4715148, "1"],
[54.91067615, 82.4716186, "3"],
[54.9107711833, 82.4719261333, "4"],
[54.9105010667, 82.4716637167, "5"],
[54.9106344833, 82.4720128, "6"],
[54.9103480333, 82.4717653333, "7"],
[54.91015655, 82.4718258167, "9"],
[54.9104869167, 82.47212505, "8"],
[54.8164228, 82.5139775667, "1"],
[54.8062942167, 82.5133165, "174"],
[54.8153860333, 82.5132536167, "21"],
[54.8101489667, 82.5102431, "70"],
[54.81422025, 82.5124331667, "36"],
[54.8662685833, 82.38685585, "101"],
[54.8696932667, 82.3909689667, "156"],
[54.86591225, 82.38439815, "82"],
[54.8665148, 82.3851989333, "100"],
[54.8672423833, 82.385944, "102"],
[54.8633081833, 82.3778155667, "18"],
[54.8628883333, 82.3783555833, "20"],
[54.8633668167, 82.3794526667, "34"],
[54.8687968833, 82.3875604333, "124"],
[54.87375745, 82.4073473, "309"],
[54.871102, 82.3963777667, "206"],
[54.8643377167, 82.3813198167, "48A"],
[54.8647317667, 82.38235055, "62"],
[54.8653946, 82.3839015333, "72"],
[54.8691804167, 82.3885183, "136"],
[54.8695428667, 82.3900536333, "150"],
[54.8708532667, 82.3954820167, "200"],
[54.8696376833, 82.3931483, "165"],
[54.8708364167, 82.3980991167, "221"],
[54.8769260167, 82.3983096333, "256B"],
[54.8739190333, 82.4060778667, "298"],
[54.8736307833, 82.4070128, "307"],
[54.8743770667, 82.4077305, "316"],
[54.8703100667, 82.3894640833, "146"],
[54.8697010667, 82.39052375, "154"],
[54.8641413167, 82.3808931667, "48E"],
[54.8673080333, 82.3779883667, "48B"],
[54.8673718333, 82.3785550833, "48C"],
[54.8674977833, 82.3793694333, "48D"],
[54.86895095, 82.3799414833, "66B"],
[54.8626150667, 82.3776425167, "14"],
[54.87166565, 82.3986665667, "254A"],
[54.8723313833, 82.4007501, "256A"],
[54.8728116833, 82.4024396333, "276A"],
[54.8735445333, 82.4044031333, "276B"],
[54.8788183833, 82.3998753, "276C"],
[54.8700288, 82.39251035, "170"],
[54.8700618833, 82.3926480833, "172"],
[54.87032565, 82.3935790167, "182"],
[54.87129395, 82.3971019667, "210"],
[54.8684687167, 82.3787688, "66A"],
[54.86917345, 82.3816180667, "66"],
[54.8994036333, 82.46781995, "2"],
[54.89908445, 82.46789945, "3"],
[54.8992924, 82.46819555, "4"],
[54.8990193667, 82.4681169167, "5"],
[54.8994638333, 82.46840135, "6"],
[54.8988995167, 82.4683006333, "7"],
[54.8992033, 82.46852295, "8"],
[54.8866583833, 82.4532039667, "33F"],
[54.8864233833, 82.4521969667, "32"],
[54.8866203333, 82.4534927833, "33E"],
[54.8874682, 82.45179065, "24A"],
[54.8826686, 82.4521089833, "48"],
[54.8871881167, 82.4517683, "26A"],
[54.8891620833, 82.4522299333, "2A"],
[54.8870288833, 82.458263333, "28A"],
[54.8847421333, 82.4521349667, "46"],
[54.8866198667, 82.4517700333, "30A"],
[54.8847517, 82.4530716833, "49"],
[54.8864979167, 82.4517625333, "32A"],
[54.8877413167, 82.4522157, "22"],
[54.8875273, 82.4522017833, "24"],
[54.8886485, 82.4522158667, "10"],
[54.8863276167, 82.4526999167, "39"],
[54.8872459167, 82.4521917333, "26"],
[54.8869694333, 82.4521850167, "28"],
[54.8884949833, 82.4526693667, "11"],
[54.8884365167, 82.4522167833, "12"],
[54.8883604667, 82.45266065, "13"],
[54.88909265, 82.4527732833, "1A"],
[54.8890918, 82.4526509167, "1"],
[54.8892247667, 82.4522300833, "2"],
[54.8889543167, 82.4526548333, "3"],
[54.88878835, 82.4526679667, "5"],
[54.8879826333, 82.4526516667, "17"],
[54.8879732333, 82.4522717, "18"],
[54.8876465167, 82.4529919333, "21"],
[54.8874666333, 82.4526953333, "23"],
[54.88718005, 82.45269155, "27"],
[54.88667215, 82.4527091167, "35"],
[54.8865333667, 82.452713, "37"],
[54.8869211167, 82.4527025667, "31"],
[54.8889064667, 82.45167665, "6"],
[54.8887104, 82.4530365333, "7"],
[54.8888331333, 82.45221635, "8"],
[54.8886320167, 82.4530411167, "9"],
[54.8866415, 82.4537552833, "33D"],
[54.8868032, 82.4537838167, "33C"],
[54.8868312167, 82.45354015, "33B"],
[54.8868582, 82.4532279333, "33A"],
[54.8867126, 82.4521915667, "30"],
[54.89138475, 82.4647044, "31"],
[54.8884147667, 82.4636648, "60B"],
[54.8944636333, 82.4644644833, "10A"],
[54.8944416833, 82.4645756833, "10"],
[54.8941219, 82.46491495, "11"],
[54.8943222167, 82.4642833333, "12A"],
[54.8930367667, 82.4648168, "15A"],
[54.8931255, 82.4648136167, "15B"],
[54.8931035167, 82.4644127333, "18"],
[54.89292315, 82.4648254167, "19"],
[54.8942371, 82.4645572667, "12"],
[54.89397735, 82.4649136, "13"],
[54.89409845, 82.4643458667, "14"],
[54.89391375, 82.4645277333, "16"],
[54.8929680833, 82.4643951, "20"],
[54.8927348833, 82.46480795, "21"],
[54.8928157667, 82.46437875, "22A"],
[54.8927337833, 82.4643644833, "22"],
[54.8925561167, 82.46478985, "23"],
[54.8923608833, 82.4647155, "25A"],
[54.8924641833, 82.46493565, "25"],
[54.8949511, 82.4649854, "1A"],
[54.8922117333, 82.4647047167, "27"],
[54.8915681667, 82.4646986833, "29"],
[54.8913701667, 82.4642759667, "30A-30D"],
[54.8913990167, 82.4642620667, "30"],
[54.8913092333, 82.46425895, "32"],
[54.8912003667, 82.46469755, "33"],
[54.8911230333, 82.4642383333, "34A"],
[54.8911486667, 82.46399235, "34B"],
[54.8911019, 82.4642380167, "34"],
[54.89098895, 82.4646725333, "35"],
[54.89084255, 82.4642192333, "36A"],
[54.8909496167, 82.46422895, "36B"],
[54.8908606333, 82.4642211667, "36"],
[54.8948280833, 82.46498935, "3"],
[54.8908666333, 82.4646632833, "37"],
[54.8907759333, 82.4646549833, "39A"],
[54.8907216667, 82.4646473167, "39B"],
[54.8906578833, 82.4646450333, "39C"],
[54.8905375667, 82.4646237167, "41"],
[54.8904761833, 82.4646328667, "43"],
[54.8902941833, 82.4641657667, "44A"],
[54.8902406833, 82.46415805, "44B"],
[54.8903436667, 82.4641675667, "44"],
[54.89028625, 82.46460345, "45"],
[54.8901877167, 82.4641515667, "46A"],
[54.89013315, 82.4641537667, "46B"],
[54.8949605167, 82.4645740333, "4"],
[54.8900607167, 82.4645841333, "47"],
[54.8900176, 82.4641449833, "48"],
[54.8899419667, 82.464572, "49A"],
[54.88987475, 82.4645733833, "49B"],
[54.8898110667, 82.4645667333, "49C"],
[54.8896632167, 82.4645695333, "49D"],
[54.8898541333, 82.46475255, "49E"],
[54.8897567333, 82.4647629, "49F"],
[54.8896634667, 82.4647669667, "49G"],
[54.8898924167, 82.4641263833, "50"],
[54.8897574667, 82.4641326833, "52"],
[54.8889242333, 82.4640623167, "54"],
[54.88865535, 82.4644431167, "55"],
[54.8887946833, 82.4638054667, "56A"],
[54.8946296667, 82.4649645, "5"],
[54.8887812167, 82.4640600833, "56"],
[54.8884208167, 82.46442915, "57"],
[54.8886385667, 82.4637760833, "58A"],
[54.8886053667, 82.4640482, "58"],
[54.8882043667, 82.4644158333, "59"],
[54.8885028333, 82.463677, "60A"],
[54.88839355, 82.4640293333, "60"],
[54.8879652167, 82.4644074, "61"],
[54.8877446333, 82.46437685, "63"],
[54.8881502667, 82.4640036667, "64"],
[54.8879700167, 82.4639859333, "66"],
[54.8878033167, 82.4639686667, "68"],
[54.8947931167, 82.4646081167, "6A"],
[54.8948649333, 82.4643251333, "6"],
[54.8944518833, 82.4649523167, "7"],
[54.8946088333, 82.4645449667, "8"],
[54.89429465, 82.4649376, "9"],
[54.8951769667, 82.4645875167, "2"],
[54.88757625, 82.46390195, "70"],
[54.8940272667, 82.4652238, "11A"],
[54.8929316167, 82.4651907833, "19A"],
[54.8910516167, 82.4651865667, "35A"],
[54.8950131667, 82.4649995667, "1"],
[54.8946681667, 82.4642288167, "8A"],
[54.8950832, 82.4643562167, "2A"],
[54.89289445, 82.4639297667, "1/22-11/22"],
[54.8839810833, 82.4856866167, "3"],
[54.8839609167, 82.4862087667, "4"],
[54.8813706667, 82.4859932667, "25"],
[54.8815762, 82.4860593167, "23"],
[54.88176925, 82.48611695, "21"],
[54.8819291833, 82.4861440667, "19"],
[54.8812535167, 82.48626755, "28"],
[54.8814419833, 82.486341, "26"],
[54.8816454, 82.486407, "24"],
[54.8817836833, 82.4864573167, "22"],
[54.8823392667, 82.4866145167, "20"],
[54.8824710167, 82.4866385333, "18"],
[54.8823897, 82.4862189833, "17"],
[54.8810208833, 82.4857673833, "27"],
[54.8809241333, 82.4860744, "32"],
[54.8810838833, 82.4862027833, "30"],
[54.8807501667, 82.4855223, "35"],
[54.8809029, 82.48565165, "33"],
[54.88077235, 82.4859607667, "34"],
[54.8805942833, 82.48538215, "37"],
[54.8806738833, 82.48500715, "39"],
[54.8804429167, 82.4856392833, "36"],
[54.8806746667, 82.48474885, "41"],
[54.8802171333, 82.4854475, "38"],
[54.8800456167, 82.4853260167, "40"],
[54.8805906167, 82.4847991833, "43"],
[54.8803164833, 82.4846505, "49"],
[54.8803990833, 82.4851850833, "45"],
[54.8802597333, 82.4850626167, "47"],
[54.8800347333, 82.4849136333, "53"],
[54.88023585, 82.4846241, "51"],
[54.87911725, 82.4844298333, "63"],
[54.8793032, 82.4845327167, "61"],
[54.8794998, 82.48456245, "59"],
[54.8796728333, 82.48464225, "57"],
[54.8798386, 82.4844502667, "55B"],
[54.87985855, 82.4847564333, "55"],
[54.8798501167, 82.4851561333, "42"],
[54.8792051, 82.48470885, "65"],
[54.8796635, 82.4850343667, "44"],
[54.8834352333, 82.4858534667, "5"],
[54.8832857667, 82.4859341667, "7"],
[54.88359745, 82.4863355833, "8"],
[54.8830905833, 82.4860275333, "9"],
[54.88377265, 82.48624865, "6"],
[54.8826329333, 82.4866849167, "16"],
[54.8825409333, 82.4862091167, "15"],
[54.8827294333, 82.4862135, "13"],
[54.8834279333, 82.4864298333, "10"],
[54.8832412, 82.4865308833, "12"],
[54.883058, 82.4865957667, "14"],
[54.8828529667, 82.4861158333, "11"],
[54.8834473167, 82.3733817, "7"],
[54.8821477, 82.3739511333, "17"],
[54.8835727833, 82.3742963167, "4"],
[54.8829996167, 82.37376495, "11"],
[54.8799677333, 82.3744603833, "49"],
[54.8801634167, 82.37443835, "43"],
[54.8131783667, 82.38169875, "10"],
[54.8129868833, 82.3819189, "8"],
[54.8122474333, 82.3825065833, "6C"],
[54.8130850833, 82.3823078833, "6A"],
[54.8124561333, 82.38300715, "6B"],
[54.81348525, 82.3804658333, "12"],
[54.81168165, 82.3801314, "16B"],
[54.8110145667, 82.3801371167, "16C"],
[54.8106325333, 82.3808725167, "16D"],
[54.8105196, 82.379982, "16E"],
[54.8134586333, 82.37986425, "16A"],
[54.8608434833, 82.4499011, "43"],
[54.8612150667, 82.44990305, "45"],
[54.8618689167, 82.4498981167, "47"],
[54.86239125, 82.4505662333, "49"],
[54.8626794667, 82.4498931333, "51"],
[54.86272035, 82.4492676833, "53"],
[54.86160045, 82.4492898833, "55"],
[54.8830900667, 82.48706325, "2"],
[54.8833400667, 82.4873493167, "3"],
[54.88330455, 82.4870247333, "4"],
[54.8835654833, 82.4872303, "5"],
[54.8835200667, 82.48693185, "6"],
[54.8837668167, 82.4872335833, "7"],
[54.88372005, 82.48686615, "8"],
[54.88385335, 82.4870479667, "9"],
[54.8831409167, 82.4873846167, "1"],
[54.8838673, 82.4868328833, "10"],
[54.88305215, 82.4682743333, "2"],
[54.8832460833, 82.4683237, "3"],
[54.8833727333, 82.4683497167, "4"],
[54.8833539333, 82.4684306333, "5"],
[54.8832353667, 82.4684359833, "6"],
[54.8356606333, 82.4259896, "44"],
[54.8361144333, 82.4254149667, "39"],
[54.8298011333, 82.4247086333, "97"],
[54.8328783, 82.4254824333, "73"],
[54.8326006333, 82.42427305, "71"],
[54.831938, 82.42577585, "85"],
[54.8296909667, 82.4253358667, "98A"],
[54.8304079333, 82.42640705, "98B"],
[54.9136688833, 82.47027315, "11"],
[54.9136547333, 82.47069685, "10"],
[54.9138316333, 82.4708094833, "12"],
[54.9137826667, 82.4703954167, "16"],
[54.91318695, 82.4705625333, "1"],
[54.913282333, 82.4701367, "3"],
[54.9134621167, 82.47077345, "4"],
[54.9134043833, 82.47044285, "5"],
[54.9136208, 82.4710819333, "6"],
[54.91350565, 82.47029995, "7"],
[54.9137004667, 82.4710525667, "8"],
[54.9135834833, 82.4699601167, "9"],
[54.8994691333, 82.46256515, "2"],
[54.8995118667, 82.4628252833, "2A"],
[54.8995123, 82.4630041667, "2B"],
[54.8994579333, 82.4622181667, "1"],
[54.8974378833, 82.4617671667, "28"],
[54.8974075167, 82.4619900333, "26"],
[54.89761855, 82.4608725333, "25"],
[54.8977565167, 82.4606562, "27"],
[54.8979072833, 82.4605283333, "29"],
[54.89808565, 82.4603934333, "31"],
[54.8982804333, 82.46037375, "33"],
[54.89837375, 82.4602651333, "35"],
[54.89802395, 82.46003665, "50"],
[54.8978844167, 82.4601356167, "48"],
[54.8977532, 82.4602402333, "46"],
[54.8976160167, 82.4603286167, "44"],
[54.89819545, 82.4599255167, "52"],
[54.8974890167, 82.4604333667, "42"],
[54.8973825833, 82.46056285, "40"],
[54.8984307833, 82.4623306333, "14"],
[54.8993176, 82.46225845, "3"],
[54.8982570167, 82.4622604, "16"],
[54.89807915, 82.4621847167, "18"],
[54.8979096167, 82.46211465, "20"],
[54.8977295167, 82.4620442, "22"],
[54.8983868833, 82.4619344833, "11"],
[54.8982446, 82.4618734, "13"],
[54.8980852, 82.46182235, "15"],
[54.8979221167, 82.4617471667, "17"],
[54.8977388167, 82.4616313167, "19"],
[54.8975900833, 82.4619512333, "24"],
[54.8976432833, 82.4613693, "21"],
[54.8976362833, 82.4611184667, "23"],
[54.8973338667, 82.4610383, "34"],
[54.89734735, 82.46128405, "32"],
[54.8973671167, 82.4615326833, "30"],
[54.8983740833, 82.4600625, "37"],
[54.8973341333, 82.46074505, "38"],
[54.8971390333, 82.46087135, "36"],
[54.8986548667, 82.4624186833, "12"],
[54.89883265, 82.462497, "10"],
[54.8990063167, 82.46257255, "8"],
[54.8991676833, 82.4626289833, "6"],
[54.8993200333, 82.4626184667, "4"],
[54.8990043833, 82.4621885667, "7"],
[54.8988871333, 82.4621417, "9"],
[54.8991505333, 82.4622658, "5"],
[54.9839604, 82.45833975, "21"],
[54.9833674167, 82.4588416833, "15"],
[54.8359882667, 82.4393378167, "84"],
[54.81988195, 82.4304131333, "303"],
[54.8180250667, 82.4265244667, "359"],
[54.8183922667, 82.42604195, "361"],
[54.8176359333, 82.4250678167, "377"],
[54.8345467667, 82.4387839833, "99"],
[54.83385615, 82.4387189, "107"],
[54.80686185, 82.4025271167, "621E"],
[54.8072254833, 82.4031670833, "621F"],
[54.8157959333, 82.4221578, "401B"],
[54.8061875667, 82.401462, "621A"],
[54.8058821833, 82.4010980167, "621B"],
[54.81469335, 82.4231989, "406"],
[54.8174082667, 82.4176129667, "413"],
[54.8141161167, 82.4226544167, "416"],
[54.8138467167, 82.4215990833, "419"],
[54.8135359833, 82.4220777667, "424"],
[54.81227475, 82.4238289333, "426"],
[54.81351715, 82.4209686667, "431"],
[54.8344727, 82.43943635, "100"],
[54.8341482167, 82.4394138833, "102"],
[54.8335249, 82.4387248167, "111"],
[54.8332444167, 82.4386937167, "113"],
[54.8258899667, 82.4354216333, "201"],
[54.8207155167, 82.4310458, "287"],
[54.82205395, 82.4322644, "273"],
[54.82211345, 82.4333285833, "268"],
[54.8116728667, 82.4194537167, "440A"],
[54.8113214333, 82.4130010333, "491A"],
[54.8163042833, 82.4288074167, "348B"],
[54.81563165, 82.4286594, "348A"],
[54.8059561833, 82.41024335, "566"],
[54.8054795833, 82.3996853333, "621D"],
[54.8049338667, 82.4001146333, "621C"],
[54.8194743833, 82.42997115, "315"],
[54.8179959833, 82.4296346167, "328"],
[54.8184434333, 82.4287788333, "327"],
[54.8064376833, 82.406161, "597B"],
[54.8062919333, 82.4056468333, "597C"],
[54.8165707167, 82.4301424, "336B"],
[54.8172738, 82.4285947167, "336A"],
[54.8189469333, 82.4303026167, "312A"],
[54.81940555, 82.4307701833, "312B"],
[54.8199143667, 82.4312459, "300"],
[54.882767667, 82.4291582, "334"],
[54.8152067667, 82.4162956667, "441B"],
[54.8142325667, 82.4148164667, "441D"],
[54.8149509, 82.4159546667, "441C"],
[54.815999, 82.482927333, "441A"],
[54.80413515, 82.4042530167, "612"],
[54.8036285, 82.4024796333, "627B"],
[54.8014316833, 82.4040596333, "636"],
[54.8026355333, 82.4024570667, "638"],
[54.8046866167, 82.4038756333, "613"],
[54.8028006833, 82.4016926167, "639A"],
[54.8015622167, 82.408231, "652"],
[54.8004875333, 82.4008727667, "670"],
[54.7997891, 82.40002805, "676"],
[54.8083442333, 82.4139592833, "509"],
[54.8074935333, 82.4139840667, "532"],
[54.8072659167, 82.4124669333, "543"],
[54.8081279, 82.40823995, "567A"],
[54.8087099667, 82.4071535667, "567C"],
[54.804962, 82.4071512, "586"],
[54.8046189167, 82.4061273333, "598"],
[54.8052894167, 82.4083249, "576"],
[54.8060052167, 82.4083508333, "571"],
[54.8053679167, 82.4062368, "597A"],
[54.8051049667, 82.4051947167, "607"],
[54.8089437667, 82.4076931167, "567B"],
[54.8113679833, 82.4200005667, "440B"],
[54.8112042667, 82.482891, "463"],
[54.8114033, 82.4191389167, "442"],
[54.81667955, 82.4240415167, "387"],
[54.8160871, 82.4248795, "390"],
[54.81503135, 82.4226562, "401A"],
[54.8158879667, 82.42335465, "393"],
[54.8104159333, 82.41701115, "477"],
[54.84176295, 82.4387852167, "25"],
[54.8394856333, 82.43871765, "53"],
[54.84315575, 82.4396268667, "4"],
[54.8382764833, 82.4387401333, "65"],
[54.8365486833, 82.4387233, "81"],
[54.83550145, 82.4387130167, "91"],
[54.8063373333, 82.40984385, "565A"],
[54.8068884167, 82.4101122333, "553"],
[54.8073266833, 82.40938595, "565B"],
[54.8022880667, 82.4015246833, "647"],
[54.8032717167, 82.3994722333, "649"],
[54.8125184833, 82.4206463, "432A"],
[54.8131087167, 82.4214898833, "432D"],
[54.81219155, 82.4220903333, "432B"],
[54.8123494833, 82.4226102667, "432C"],
[54.8323999167, 82.4388484167, "113/1"],
[54.8137884667, 82.4184721333, "439B"],
[54.8128705833, 82.4202196333, "439A"],
[54.8030845, 82.4029651, "634"],
[54.80229035, 82.4038689333, "634A"],
[54.8016416, 82.4044987167, "634B"],
[54.8040659833, 82.4028728333, "627A"],
[54.8039385667, 82.4012164167, "627C"],
[54.8041331833, 82.4011953333, "627D"],
[54.8104539833, 82.4114936333, "501"],
[54.8095276, 82.41551535, "491C"],
[54.8104942333, 82.4142607333, "491B"],
[54.8118822333, 82.4251615167, "426A"],
[54.9146426833, 82.46333945, "8"],
[54.9146966667, 82.4641698333, "12"],
[54.9148385667, 82.4646229167, "14"],
[54.9145846833, 82.4637018, "10"],
[54.9148759167, 82.4632119667, "6"],
[54.9150353667, 82.4631399, "4"],
[54.8791983833, 82.48491125, "1"],
[54.8794456833, 82.4852828333, "4"],
[54.8795405, 82.4855742333, "6"],
[54.8796772167, 82.4856965, "8"],
[54.87980185, 82.4857916833, "10"],
[54.8796864, 82.4861288, "15"],
[54.8797264167, 82.4859489333, "12"],
[54.8795614, 82.4860496167, "13"],
[54.8794049667, 82.4858653167, "11"],
[54.8792908167, 82.4856798667, "9"],
[54.8791893, 82.4854042167, "5"],
[54.879194, 82.4855697, "7"],
[54.87919295, 82.4851510333, "3"],
[54.9021503333, 82.4819923833, "1"],
[54.9020893333, 82.4817469667, "2"],
[54.90202325, 82.4814764333, "3"],
[54.90189885, 82.4813368167, "4"],
[54.9017681, 82.4813746667, "5"],
[54.9017408667, 82.4815826667, "6"],
[54.9018523, 82.4818607167, "7"],
[54.90192475, 82.4821145, "8"],
[54.9122682, 82.46593575, "11"],
[54.9122654667, 82.4666392333, "2"],
[54.9124824333, 82.4664875, "1"],
[54.9126646667, 82.4661762167, "3"],
[54.9121691, 82.4663371, "4"],
[54.9126312167, 82.4661364333, "5"],
[54.9121084167, 82.46614215, "6"],
[54.91239705, 82.46620525, "7"],
[54.912165, 82.4659997167, "8"],
[54.91234125, 82.4659673167, "9"],
[54.8640527833, 82.4896800333, "1/239"],
[54.8637439833, 82.4893278333, "2/239"],
[54.8399393, 82.4691242833, "563"],
[54.8403040167, 82.4695932333, "555"],
[54.8626741167, 82.4890199667, "250"],
[54.86235545, 82.4877547333, "263"],
[54.8621190833, 82.4881775833, "260"],
[54.8697908333, 82.4976855333, "2/143"],
[54.8696097167, 82.50222845, "109"],
[54.8650994667, 82.4906942667, "217"],
[54.8587062667, 82.4842270833, "308"],
[54.8585393667, 82.4832368167, "323"],
[54.856982, 82.4821791333, "337"],
[54.8557220333, 82.4813075, "357"],
[54.87269675, 82.51109805, "9"],
[54.86818685, 82.4965807167, "154"],
[54.8391881333, 82.4691244833, "570"],
[54.8392424167, 82.4682793833, "573"],
[54.8384787167, 82.4682486667, "580"],
[54.8380699833, 82.4677177667, "586"],
[54.83591845, 82.4652008167, "1/620"],
[54.8356297, 82.4656015333, "2/620"],
[54.85443655, 82.48126465, "362"],
[54.8543465667, 82.4803770667, "363"],
[54.8533677, 82.4796417833, "383"],
[54.8400570333, 82.4693165167, "559"],
[54.8701502, 82.5066921333, "58"],
[54.8688167, 82.5031792667, "94"],
[54.8633276833, 82.48971255, "240"],
[54.84499075, 82.47397555, "489"],
[54.8390078667, 82.4675286, "579"],
[54.8615817667, 82.4874484667, "272"],
[54.8611261, 82.48692335, "1/276"],
[54.8609821, 82.48677485, "2/276"],
[54.8443942167, 82.4735167, "491"],
[54.84453425, 82.4741157833, "490"],
[54.8728439333, 82.5114111333, "5"],
[54.8479137833, 82.47588805, "449"],
[54.8694130667, 82.5004653167, "118"],
[54.8381128333, 82.4689194667, "578"],
[54.8387493167, 82.4686557833, "576"],
[54.834946, 82.4616395, "648"],
[54.8355279667, 82.4648596667, "626"],
[54.8352287, 82.46082495, "670"],
[54.84359945, 82.4735256167, "500"],
[54.8437138833, 82.4730056833, "501"],
[54.8433661667, 82.4727594167, "511"],
[54.8429640667, 82.4725448333, "513"],
[54.8424090833, 82.4720656833, "517"],
[54.8419261, 82.4716311333, "529"],
[54.84138045, 82.4707106667, "535"],
[54.8407243, 82.4700550167, "551"],
[54.84032605, 82.4702964, "552"],
[54.8397895, 82.46968935, "562"],
[54.83966945, 82.4688137833, "567"],
[54.8458821833, 82.4743360167, "479"],
[54.8523557667, 82.4795548667, "394"],
[54.8519909833, 82.4785619833, "401"],
[54.85128865, 82.4790768167, "408"],
[54.8505837, 82.4777973667, "419"],
[54.8494416833, 82.4767902167, "429"],
[54.8501747833, 82.478082, "422"],
[54.8487495333, 82.477303, "446"],
[54.8613924167, 82.4866768333, "275"],
[54.8612592667, 82.48651665, "277"],
[54.8606625, 82.4863779, "280"],
[54.8602587667, 82.4860168333, "288"],
[54.8662275, 82.4932509, "192"],
[54.8656668, 82.4925030333, "206"],
[54.8718011, 82.50936105, "31"],
[54.871327, 82.50837775, "41"],
[54.8481012833, 82.4755436333, "455"],
[54.8662202833, 82.4971715833, "2/164"],
[54.8665327833, 82.4968656167, "1/164"],
[54.87262005, 82.5101317, "11"],
[54.8407464167, 82.4693628, "553"],
[54.8687301, 82.50368985, "92"],
[54.8576066333, 82.4826215667, "331"],
[54.867679, 82.4952846833, "164"],
[54.8698948833, 82.4990379333, "133"],
[54.8639344, 82.49046205, "230"],
[54.8645916667, 82.4912248333, "224"],
[54.8710460833, 82.50036065, "125"],
[54.8694796667, 82.4976021667, "1/143"],
[54.8733131, 82.4691004333, "3A"],
[54.87406055, 82.4694125667, "6A"],
[54.8735341167, 82.469327, "5"],
[54.8735109667, 82.46960345, "7"],
[54.87351105, 82.4698807333, "11"],
[54.8735358667, 82.47009225, "13"],
[54.8736709667, 82.4702864167, "17"],
[54.8737941667, 82.47025885, "16"],
[54.8738211333, 82.4693453167, "4"],
[54.8737987667, 82.46968045, "8"],
[54.8738769167, 82.4699632, "10"],
[54.8739402833, 82.4701521167, "12"],
[54.8732443833, 82.4692419333, "3B"],
[54.8740679833, 82.4695514833, "6B"],
[54.8739830167, 82.4704122667, "14"],
[54.8735580667, 82.4702317, "15"],
[54.87328745, 82.4697687167, "9"],
[54.8738628167, 82.46909085, "2"],
[54.8735833, 82.4690007, "1"],
[54.9140601833, 82.4734438833, "1"],
[54.91414235, 82.4726753, "7A"],
[54.9148196333, 82.4729240333, "4"],
[54.9145959167, 82.4727449, "5"],
[54.9144294, 82.4728081667, "6"],
[54.9142862333, 82.4729454, "7"],
[54.9140804667, 82.4729594, "8"],
[54.91442545, 82.4732771, "2A"],
[54.9146292, 82.47320695, "3"],
[54.9142898833, 82.4733283333, "2"],
[54.8924708, 82.4694829667, "3"],
[54.8921866833, 82.4690726, "4-6"],
[54.8744290667, 82.4729675333, "16"],
[54.8747743333, 82.4729266667, "17"],
[54.8743306833, 82.4749814667, "2"],
[54.8743712167, 82.4747777167, "4"],
[54.8743979833, 82.4745281667, "6"],
[54.8744096167, 82.47429405, "8"],
[54.8744245167, 82.4740094333, "10"],
[54.8744545333, 82.4736160667, "12"],
[54.8742322333, 82.47382395, "10A"],
[54.87422675, 82.47369315, "12A"],
[54.8742394, 82.4730406667, "16A"],
[54.8742450667, 82.4731634667, "14A"],
[54.8744790667, 82.4732784833, "14"],
[54.8747754833, 82.4731559, "15"],
[54.8747613167, 82.4734085833, "13"],
[54.8747389, 82.4736529667, "11"],
[54.8747211167, 82.47387885, "9"],
[54.8747006167, 82.4741313, "7"],
[54.8746909667, 82.4743708167, "5"],
[54.8746798167, 82.4746769, "3"],
[54.8748711167, 82.4748117167, "3A"],
[54.8748328833, 82.4749142833, "1A"],
[54.874621, 82.4750391, "1"],
[54.8755351667, 82.4795168667, "6A"],
[54.8754681, 82.4798997667, "6"],
[54.8756842833, 82.4798735833, "8"],
[54.8756412167, 82.4794951833, "8A"],
[54.8758023167, 82.4803141667, "5"],
[54.8757598667, 82.4801058, "7"],
[54.8757471833, 82.4799721833, "9"],
[54.8755322, 82.4802420833, "3"],
[54.8753549833, 82.47993535, "4"],
[54.888292, 82.4617109667, "4A"],
[54.8820907333, 82.4622059833, "5"],
[54.8815066, 82.4617161667, "4B"],
[54.888234333, 82.4618948333, "6A"],
[54.8815026667, 82.46184895, "6B"],
[54.8815932167, 82.46217415, "10A"],
[54.8817450167, 82.46226225, "10"],
[54.8818722667, 82.4626555167, "11"],
[54.8817309, 82.4624690333, "12"],
[54.8821211333, 82.4617608833, "1"],
[54.8817646833, 82.4615252167, "2A"],
[54.8815099, 82.4615357667, "2B"],
[54.88209615, 82.4619084, "3"],
[54.8820657333, 82.4624910833, "7"],
[54.8817491333, 82.4620671833, "8A"],
[54.8814882667, 82.4620343, "8B"],
[54.8820256333, 82.4626954, "9"],
[54.9011387, 82.4845455833, "11A"],
[54.9004465667, 82.4842316167, "6"],
[54.9006268333, 82.4836419, "1"],
[54.9005414333, 82.4845609667, "10"],
[54.9009292833, 82.4847187667, "11"],
[54.9009982, 82.48493945, "13"],
[54.900608, 82.4848214333, "14"],
[54.9002908667, 82.4835936167, "2"],
[54.9003859333, 82.4839906667, "4"],
[54.9007548667, 82.4840674, "5"],
[54.9008090833, 82.4842714333, "7"],
[54.90027845, 82.4844867667, "8"],
[54.90087325, 82.4844819167, "9"],
[54.9010882333, 82.4852001, "15"],
[54.9007465833, 82.4850981333, "16"],
[54.9008384, 82.48536275, "18"],
[54.9009003833, 82.4836903667, "3A"],
[54.9006948, 82.48386545, "3"],
[54.8352114167, 82.3932620667, "614"],
[54.8358616, 82.3932373667, "607"],
[54.8527932167, 82.4481416, "66"],
[54.8535776833, 82.4477748333, "59"],
[54.8513053333, 82.4468875167, "88"],
[54.8367923167, 82.39439545, "597"],
[54.8356857333, 82.39511535, "594"],
[54.8338485, 82.3905351667, "644"],
[54.8342344833, 82.3914293833, "636"],
[54.8349352, 82.39110985, "631"],
[54.8340942167, 82.3894187167, "647"],
[54.8361288, 82.3943564333, "603"],
[54.835456, 82.3923533167, "621"],
[54.8316758833, 82.3851704333, "690"],
[54.82606465, 82.3729124, "823A"],
[54.8360247333, 82.40845075, "472"],
[54.8367576167, 82.4058547167, "499"],
[54.8307850333, 82.3833224167, "716"],
[54.8297911333, 82.3838338167, "722A"],
[54.82856305, 82.3853371, "722B"],
[54.8366530833, 82.4158296167, "407"],
[54.8343563333, 82.3899946667, "645"],
[54.83378605, 82.3887814833, "649"],
[54.8383438833, 82.4167502667, "403A"],
[54.8269138333, 82.3707719, "823B"],
[54.8262433167, 82.37126425, "823C"],
[54.8278735833, 82.3745076, "791C"],
[54.82803615, 82.3751116833, "791B"],
[54.8284354167, 82.3743400333, "791D"],
[54.8283312333, 82.3722626167, "803H"],
[54.8308135833, 82.3857800333, "700A"],
[54.83039575, 82.3861873667, "700B"],
[54.8297918, 82.3866039833, "700C"],
[54.8323622833, 82.3869592167, "680A"],
[54.8317271833, 82.3872918333, "680B"],
[54.8320544167, 82.3863078833, "680C"],
[54.8265114833, 82.3737262, "811A"],
[54.8268406667, 82.37269475, "811B"],
[54.8272920833, 82.3716203, "811C"],
[54.8537437333, 82.4489413667, "62"],
[54.83192005, 82.3841341833, "695"],
[54.8368657833, 82.4028889833, "525"],
[54.83376425, 82.3968886333, "590B"],
[54.8299130333, 82.3859233667, "702C"],
[54.8305810833, 82.38512625, "702B"],
[54.8360455333, 82.4081179333, "474"],
[54.8276760833, 82.3808082167, "756C"],
[54.8283299333, 82.3802092167, "756B"],
[54.85043345, 82.4461019, "100"],
[54.8297131833, 82.38286445, "724A"],
[54.82929325, 82.383521, "724B"],
[54.8369757, 82.3983033667, "571"],
[54.8376989333, 82.4166211, "403B"],
[54.8368311167, 82.4050104667, "505"],
[54.8412127667, 82.4050228833, "491A"],
[54.83852105, 82.4062947, "491B"],
[54.8338348833, 82.3934827333, "622B"],
[54.8330032, 82.3939467333, "622C"],
[54.8282068, 82.376844, "775A"],
[54.8295163167, 82.3755049667, "775B"],
[54.828404, 82.37718215, "775C"],
[54.8362426, 82.39711805, "578"],
[54.8361603, 82.39675875, "580"],
[54.8424267833, 82.4340512167, "232"],
[54.84114775, 82.4311295833, "272"],
[54.82872315, 82.3709866833, "803A"],
[54.8285930667, 82.3703004167, "803B"],
[54.8294768667, 82.3691337, "803C"],
[54.8292017, 82.36888125, "803D"],
[54.8285291333, 82.36580345, "803E"],
[54.8298995333, 82.3673114167, "803F"],
[54.8302568833, 82.36760835, "803G"],
[54.8267714167, 82.3742385167, "807"],
[54.83126665, 82.3844291833, "702A"],
[54.83016355, 82.3818740833, "734"],
[54.8296635167, 82.3807643167, "742"],
[54.82974665, 82.3798092, "747"],
[54.829114, 82.3799039833, "752"],
[54.8288072833, 82.3779985667, "765"],
[54.8278203667, 82.3760339333, "789"],
[54.8274609333, 82.3753562, "791A"],
[54.8320049, 82.39796425, "592B"],
[54.8304380667, 82.3993220667, "592C"],
[54.8323366667, 82.3982387333, "592D"],
[54.8332103167, 82.39666495, "590A"],
[54.8362232667, 82.4049506333, "504"],
[54.83689715, 82.4034307333, "523"],
[54.8362677, 82.4030851833, "522"],
[54.8363718333, 82.4003976167, "548"],
[54.836423, 82.3953457167, "585"],
[54.83596855, 82.3959414667, "586"],
[54.8392194, 82.4133888333, "439"],
[54.8367003667, 82.4102236167, "461"],
[54.83586315, 82.412182333, "442"],
[54.8387438833, 82.4244664667, "318"],
[54.8382094333, 82.42266185, "346"],
[54.8366223667, 82.4173578167, "396"],
[54.8405799833, 82.4294097167, "284"],
[54.8409799, 82.4286117333, "289"],
[54.8404157, 82.4273133667, "291"],
[54.8448297, 82.4386074, "188"],
[54.8445996333, 82.4385307833, "190"],
[54.8445953833, 82.4381869167, "192"],
[54.8462362333, 82.4406972, "162"],
[54.8453950333, 82.4394750167, "180"],
[54.8561178167, 82.4522334, "11"],
[54.8560307, 82.4511923667, "17"],
[54.8361288, 82.4061807167, "492"],
[54.83609445, 82.40683275, "490"],
[54.8545275667, 82.44950565, "40"],
[54.8375230333, 82.4199872333, "372"],
[54.8388781167, 82.4226393667, "343"],
[54.83701825, 82.41844345, "378"],
[54.8371192833, 82.4187303167, "376"],
[54.8373785667, 82.4194973167, "374"],
[54.8367387167, 82.4085570167, "473"],
[54.8318677333, 82.3858444, "688"],
[54.8327873167, 82.3878064833, "674"],
[54.83304365, 82.3883507667, "664"],
[54.8366133333, 82.4130614667, "427"],
[54.8508733333, 82.44641935, "94"],
[54.8433085667, 82.4359371667, "212"],
[54.8376679667, 82.3994774833, "549"],
[54.8388004167, 82.3998009833, "549C"],
[54.8369648167, 82.40033875, "549B"],
[54.8376661833, 82.3999770333, "549A"],
[54.8368055667, 82.3968196667, "575"],
[54.8369513667, 82.39729965, "573"],
[54.836328, 82.3975344167, "576"],
[54.8419685667, 82.4332863667, "240"],
[54.83147865, 82.3703224333, "781A"],
[54.8302962167, 82.3727004833, "781B"],
[54.8300511833, 82.3734676833, "781C"],
[54.9155750333, 82.4788872333, "103"],
[54.9080710333, 82.4815503833, "39C"],
[54.9081354167, 82.48171275, "39B"],
[54.90819845, 82.4819203833, "39A"],
[54.9165609667, 82.4784770333, "115"],
[54.91497395, 82.4792572167, "99"],
[54.9096164833, 82.4817164167, "49"],
[54.9116786667, 82.48074935, "69"],
[54.9140226, 82.479658, "85"],
[54.9069150833, 82.4829900333, "27A"],
[54.9069469833, 82.4828211667, "27B"],
[54.9141799333, 82.4796010667, "87"],
[54.9148269, 82.4793132333, "95"],
[54.9148061667, 82.47892315, "97"],
[54.9052287833, 82.4834456667, "7A"],
[54.9157397167, 82.4785532167, "107A"],
[54.9164115167, 82.4783404167, "113"],
[54.9162113333, 82.4786140333, "109"],
[54.9159243667, 82.4787397833, "107B"],
[54.91564195, 82.4783057333, "107"],
[54.9095836167, 82.48142755, "49A"],
[54.9097563, 82.4813824667, "51A"],
[54.9142505167, 82.4798245, "89A"],
[54.9143203667, 82.4795241, "89"],
[54.9143582167, 82.4791171833, "91A"],
[54.90809605, 82.4820482833, "37A"],
[54.9080426833, 82.4818123, "37B"],
[54.9079928333, 82.4816048, "37C"],
[54.9144982167, 82.4794426833, "91"],
[54.9146732833, 82.4793797, "93"],
[54.9046052333, 82.48406395, "1"],
[54.90479665, 82.4839646833, "3"],
[54.9049845333, 82.4838759833, "5"],
[54.9061106, 82.4833581667, "17"],
[54.9062431667, 82.4833112333, "19"],
[54.9063920333, 82.4832255333, "21"],
[54.9065708, 82.48314765, "23"],
[54.9067455333, 82.4830679333, "25"],
[54.90686575, 82.4825972667, "29"],
[54.9053759667, 82.4837128167, "11"],
[54.9055325, 82.4836456167, "13"],
[54.9057146333, 82.4835634667, "15"],
[54.9080300333, 82.4824985, "35"],
[54.9081798333, 82.4824187833, "37"],
[54.90842625, 82.4822687667, "39"],
[54.90871305, 82.4821525333, "43"],
[54.9071454167, 82.4828962333, "31"],
[54.90945405, 82.4818068167, "47"],
[54.9097787167, 82.4816407833, "51"],
[54.9101221667, 82.48147745, "55"],
[54.9099619333, 82.4815613833, "53"],
[54.9108703, 82.48113905, "57"],
[54.9111010167, 82.4810227833, "61"],
[54.9113033333, 82.4806476167, "63A"],
[54.9113063333, 82.4809305333, "63"],
[54.9113486333, 82.48054435, "65"],
[54.9115162333, 82.4808384167, "67"],
[54.9118321, 82.4806828667, "71"],
[54.912005, 82.4805931333, "73"],
[54.9126924, 82.4801856167, "75"],
[54.9128904333, 82.48013955, "77"],
[54.91306105, 82.4801038667, "79"],
[54.91323275, 82.4800307667, "81"],
[54.90504305, 82.48350075, "7"],
[54.9161411, 82.4791161, "104"],
[54.9052017167, 82.4837928833, "9"],
[54.9048593333, 82.4837002833, "5A"],
[54.9134008167, 82.4799760333, "83"],
[54.91608025, 82.4781871, "111A"],
[54.9159769333, 82.4778862, "111B"],
[54.91609255, 82.4778227833, "111C"],
[54.9162477333, 82.4781089667, "111D"],
[54.8954434833, 82.47689195, "1"],
[54.7968509833, 82.4409205333, "218"],
[54.7967954, 82.4415974333, "226"],
[54.79061135, 82.4311808833, "105"],
[54.7936930167, 82.4323678167, "144"],
[54.7936793, 82.4341171833, "169"],
[54.7906754167, 82.4300550333, "101"],
[54.7923387667, 82.4305234833, "114"],
[54.7921506667, 82.4312033333, "119"],
[54.79638115, 82.44350555, "244"],
[54.9026378, 82.4249371167, "6"],
[54.9018287167, 82.4251090167, "15"],
[54.9005140167, 82.4267575167, "32"],
[54.90030005, 82.4272810167, "36"],
[54.9000367833, 82.4266413167, "1/45"],
[54.8999172167, 82.4269248667, "2/45"],
[54.8998128167, 82.42722285, "3/45"],
[54.8997664167, 82.4278138333, "46"],
[54.89874045, 82.42933485, "47"],
[54.90246715, 82.4251130833, "8"],
[54.98415945, 82.5440391833, "1/398"],
[54.9842023, 82.5446759833, "398"],
[54.9673053833, 82.5493618, "1/200"],
[54.9595488167, 82.5503643667, "2/94"],
[54.9548066833, 82.5547442167, "41"],
[54.975043, 82.5502804667, "288"],
[54.9674483333, 82.54948405, "2/200"],
[54.9675936167, 82.54960055, "3/200"],
[54.9536896833, 82.5558200833, "21"],
[54.9537523333, 82.5551846667, "24"],
[54.9758721, 82.55151395, "297"],
[54.9715911333, 82.5505416, "246"],
[54.97615305, 82.5531409833, "1/299"],
[54.9759959833, 82.553822167, "2/299"],
[54.9762314333, 82.5517778833, "3/299"],
[54.9789959667, 82.5511051167, "1/317"],
[54.9791978667, 82.5509703167, "2/317"],
[54.97016405, 82.5511682333, "233"],
[54.9840100667, 82.5422511833, "3/398"],
[54.9832081667, 82.5409176, "4/398"],
[54.9626150333, 82.5485202333, "1/142"],
[54.9620708667, 82.5493090333, "139"],
[54.9646945333, 82.5484742, "164"],
[54.95884865, 82.5515776333, "91"],
[54.9588039667, 82.5510064, "1/94"],
[54.9794108833, 82.5497014333, "332"],
[54.9806783167, 82.5477771, "352"],
[54.8757744167, 82.46972585, "1"],
[54.8758043667, 82.4700843, "3"],
[54.8758559833, 82.4703261667, "5"],
[54.8759855667, 82.4703921667, "7"],
[54.8761207333, 82.4703036833, "9"],
[54.8763731833, 82.4703581, "8B"],
[54.8763879, 82.4701746167, "8A"],
[54.8760971833, 82.4699428, "6"],
[54.8763947, 82.46978015, "4"],
[54.8760231167, 82.4695721, "2"],
[54.84887105, 82.5612401333, "268"],
[54.8480716667, 82.5605471, "1/271"],
[54.8481743833, 82.5599216, "2/271"],
[54.8475651333, 82.5602482833, "273"],
[54.8549548833, 82.5645155167, "187"],
[54.8590531333, 82.56929455, "111"],
[54.8579502, 82.5697828667, "1/128"],
[54.8577433333, 82.5697812167, "2/128"],
[54.8663423167, 82.5687757833, "25"],
[54.8659378833, 82.5701593333, "1/32"],
[54.8656144667, 82.5703594167, "2/32"],
[54.9075306667, 82.4735409, "8"],
[54.90741835, 82.4736250333, "12"],
[54.9077710167, 82.4736747, "3"],
[54.90756245, 82.4735306833, "7"],
[54.90776065, 82.4736345167, "4"],
[54.9076790833, 82.4734552333, "6"],
[54.90770165, 82.4734532167, "5"],
[54.90742555, 82.4736053833, "11"],
[54.9074725833, 82.4739170833, "14"],
[54.9074575333, 82.47388525, "13"],
[54.90752205, 82.4737226167, "10"],
[54.9075427667, 82.4737034667, "9"],
[54.9078406167, 82.4738848333, "1"],
[54.9078192667, 82.4738328667, "2"],
[54.907982667, 82.4742687333, "19"],
[54.9076409333, 82.4739459, "15"],
[54.9077643333, 82.4742689, "18"],
[54.9077539833, 82.4742287, "17"],
[54.9076577333, 82.47400055, "16"],
[54.9079030333, 82.4742141667, "20"],
[54.9156256167, 82.4748749833, "78"],
[54.9146128333, 82.4721344167, "56A"],
[54.9151661833, 82.4733835167, "66"],
[54.9140138, 82.4694897, "30"],
[54.9140857167, 82.46969035, "32"],
[54.9144033, 82.4695158, "33"],
[54.91414165, 82.4698978167, "34"],
[54.91444875, 82.4697295833, "35"],
[54.9142653833, 82.4703260667, "38"],
[54.9142211667, 82.4701128667, "36"],
[54.9155440833, 82.4732913, "65"],
[54.9134283, 82.4674369333, "14"],
[54.9155934667, 82.4735220833, "67"],
[54.9151737667, 82.4721487333, "57"],
[54.9155787333, 82.4746912167, "76"],
[54.9143332167, 82.4693118167, "29"],
[54.9151155, 82.4718793167, "55"],
[54.9134783167, 82.4676862167, "16"],
[54.91350365, 82.4678403, "18"],
[54.9135371667, 82.4680652, "20"],
[54.9135827167, 82.4682467, "22"],
[54.9136676, 82.4684140667, "24"],
[54.91375, 82.4685284833, "26"],
[54.9144983333, 82.4699386333, "39"],
[54.9145579833, 82.4701247833, "41"],
[54.9146344333, 82.4703215833, "43"],
[54.9140692167, 82.4706085833, "46"],
[54.91469445, 82.47051275, "47"],
[54.9143359333, 82.4705744833, "48"],
[54.9147432833, 82.47069995, "49"],
[54.9146982, 82.4717894167, "54"],
[54.9147643333, 82.47204645, "56"],
[54.91485235, 82.4723157167, "58"],
[54.9149395167, 82.4725939833, "60"],
[54.9144000333, 82.4707812, "50"],
[54.9148043167, 82.4709096, "51"],
[54.9157513167, 82.4752532333, "82"],
[54.9158039333, 82.47545195, "84"],
[54.9156901667, 82.4750640167, "80"],
[54.9158563833, 82.4756482667, "86"],
[54.91508355, 82.4731087, "64"],
[54.9154807667, 82.4730812167, "63"],
[54.9154616667, 82.4742882833, "72"],
[54.9155282, 82.47449895, "74"],
[54.9790357333, 82.4624267667, "19"],
[54.9791358667, 82.4611471, "6"],
[54.9797030333, 82.4636025333, "30"],
[54.9790060167, 82.4621910833, "17"],
[54.9786417667, 82.4608476833, "5"],
[54.9804888333, 82.4691719, "83"],
[54.9793757333, 82.4644864667, "37"],
[54.9794654667, 82.4649678833, "39"],
[54.9815936, 82.4721696167, "104"],
[54.9806346333, 82.46753305, "62"],
[54.9801957667, 82.4694512667, "1/83"],
[54.9813943, 82.4789249667, "2/172"],
[54.9811831333, 82.4791219167, "1/172"],
[54.9815603333, 82.4787492833, "3/172"],
[54.9817079333, 82.4785843667, "4/172"],
[54.98098455, 82.4692836, "84"],
[54.9797661167, 82.4828635833, "209"],
[54.9819302167, 82.4751814833, "130"],
[54.9810331167, 82.4792768333, "172"],
[54.9791101833, 82.4807109667, "193"],
[54.9211995833, 82.54297615, "118"],
[54.9213446, 82.5421832, "105"],
[54.9211681167, 82.54216685, "107"],
[54.9209082667, 82.5425332333, "111"],
[54.9208103667, 82.542655, "113"],
[54.92117155, 82.5424739667, "109"],
[54.9206148667, 82.5429439167, "119"],
[54.9207782667, 82.5431801, "117"],
[54.9210005833, 82.542809, "115"],
[54.9223620333, 82.5419011, "44"],
[54.9221513667, 82.5414861833, "22"],
[54.9220122833, 82.54171955, "48"],
[54.9214541667, 82.5419499167, "103"],
[54.9216856333, 82.54226385, "110"],
[54.92188255, 82.54189345, "70"],
[54.9216037833, 82.5417236667, "79"],
[54.9217873667, 82.5420768833, "90"],
[54.9207292667, 82.5435594333, "127"],
[54.9215061833, 82.5424147833, "112"],
[54.9214096333, 82.5425683833, "114"],
[54.9212674167, 82.5427841667, "116"],
[54.9211160833, 82.5431952167, "120"],
[54.9210373167, 82.5434004167, "122"],
[54.9209575167, 82.5435602167, "124"],
[54.9206745667, 82.5433710667, "125"],
[54.92082745, 82.54361115, "128"],
[54.9209216, 82.5437402667, "126"],
[54.9205988167, 82.5431733333, "123"],
[54.9204654167, 82.54300295, "121"],
[54.9059849833, 82.4685779333, "10"],
[54.9063778167, 82.4688591, "11"],
[54.9057737333, 82.4693218333, "2"],
[54.9064842, 82.4693450167, "7"],
[54.9060801333, 82.46881255, "12"],
[54.9060230333, 82.46940395, "1"],
[54.9060816167, 82.4691977833, "3"],
[54.90581185, 82.4691003833, "4"],
[54.9063729333, 82.4693653667, "5"],
[54.9058748833, 82.4689197333, "6"],
[54.90586325, 82.46860955, "8"],
[54.9064269833, 82.4690855667, "9"],
[54.8955635667, 82.4714488333, "3"],
[54.89574055, 82.4716702667, "6"],
[54.8760291333, 82.4752209667, "4"],
[54.8761012667, 82.4756677333, "5"],
[54.8761172, 82.4749063833, "6A"],
[54.8762485667, 82.4748657167, "6B"],
[54.8765363167, 82.4750690167, "10"],
[54.87633255, 82.4751297667, "8"],
[54.8767972333, 82.4754502, "13"],
[54.8767630833, 82.4749863833, "12"],
[54.87581215, 82.4752698833, "2"],
[54.8757609167, 82.4757446833, "1"],
[54.8774312833, 82.4746756833, "25"],
[54.87757445, 82.4749078, "23"],
[54.8773315167, 82.4749104, "21"],
[54.8772196833, 82.4750822833, "19"],
[54.8771222167, 82.47521495, "17"],
[54.8769752, 82.4753515167, "15"],
[54.8766353, 82.47550835, "11"],
[54.8764627667, 82.4755687833, "9"],
[54.8762885333, 82.4756105, "7"],
[54.8759247333, 82.4757173667, "3"],
[54.8769794333, 82.4747672167, "14"],
[54.97891525, 82.4601520333, "772"],
[54.9464645333, 82.4822205167, "329"],
[54.9470361333, 82.4829135, "337"],
[54.9713491167, 82.4612835833, "684"],
[54.9615547167, 82.4636732, "578"],
[54.9642195, 82.4617228, "606"],
[54.9214648167, 82.4783231833, "49"],
[54.9212708833, 82.47781485, "1/49"],
[54.9230265, 82.478089, "65"],
[54.9669955167, 82.46143295, "653"],
[54.9801441, 82.4596936833, "784"],
[54.91909305, 82.4782088, "27"],
[54.9278700667, 82.4760814333, "122"],
[54.9393246667, 82.4798381833, "256"],
[54.98099395, 82.4594168167, "788"],
[54.9235198, 82.4765764833, "76"],
[54.9838248833, 82.4507092333, "885"],
[54.9840650667, 82.4492086167, "893"],
[54.9819271833, 82.4584667833, "812"],
[54.97680425, 82.4605180667, "746"],
[54.9772555, 82.4612509, "751"],
[54.9553357833, 82.4689185833, "484"],
[54.9549016, 82.4705773167, "469"],
[54.9549819, 82.4681984167, "492"],
[54.95610765, 82.4687586833, "495"],
[54.9558325167, 82.4681527833, "496"],
[54.9563786, 82.4673479667, "506"],
[54.9588897333, 82.4662872333, "549"],
[54.9374805167, 82.4792935833, "232"],
[54.9385204667, 82.4796240833, "250"],
[54.9418827167, 82.48053625, "282"],
[54.9422215667, 82.4814613667, "291"],
[54.9452781, 82.4815002, "318"],
[54.9482466667, 82.4790639833, "372"],
[54.9497215167, 82.47691875, "396"],
[54.9341688833, 82.4782591167, "196"],
[54.9265146833, 82.4765383667, "109"],
[54.93050445, 82.4778804333, "151"],
[54.9283181, 82.4771124167, "129"],
[54.9251162, 82.4762160667, "98"],
[54.92343355, 82.4771558167, "73"],
[54.9239441667, 82.4794231667, "75"],
[54.9241087667, 82.4769972833, "83"],
[54.9222823667, 82.4774759333, "61"],
[54.9199369167, 82.4774060333, "34"],
[54.9203899333, 82.475518, "36"],
[54.9203777167, 82.4773256, "40"],
[54.9206612167, 82.4765307833, "42"],
[54.9210448, 82.4771433833, "44"],
[54.9220389167, 82.47755095, "57"],
[54.91929535, 82.4775611167, "26"],
[54.9216718667, 82.4775874667, "55"],
[54.98317275, 82.4515617, "874"],
[54.9834542667, 82.449681, "890"],
[54.94112955, 82.48040145, "278"],
[54.9511382833, 82.4768400333, "401"],
[54.9529536833, 82.4734404167, "447"],
[54.9818127667, 82.4589793667, "794"],
[54.9216345833, 82.4771334167, "50"],
[54.9817718333, 82.4597500333, "789"],
[54.8840469167, 82.4595505333, "3A"],
[54.8836735833, 82.4604158333, "4B"],
[54.88403835, 82.4600429333, "5"],
[54.8834882, 82.4601379, "1A"],
[54.88367125, 82.4597893667, "1"],
[54.8835863, 82.4604458167, "2A"],
[54.8835968, 82.4601401333, "2"],
[54.88386135, 82.4597867, "3"],
[54.88376075, 82.4601527667, "4"],
[54.8838918833, 82.4601641667, "6"],
[54.8842726667, 82.4597851667, "5A"],
[54.8840725833, 82.4598049333, "3B"],
[54.8976647333, 82.4710761333, "3"],
[54.8975512333, 82.4708644667, "7"],
[54.8973241167, 82.4703941833, "15"],
[54.8972415667, 82.4702575667, "17"],
[54.8973903333, 82.4705850167, "13"],
[54.8974731667, 82.4707213, "9"],
[54.8976014, 82.4709784167, "5"],
[54.8973658833, 82.4713826333, "1"],
[54.88263055, 82.4789374667, "2"],
[54.88295785, 82.4787557167, "3"],
[54.88262705, 82.4787408333, "4"],
[54.8828655833, 82.47856665, "5"],
[54.8826968, 82.4785708667, "6"],
[54.8829381167, 82.4790952, "1"],
[54.8829405833, 82.4789477, "1A"],
[54.9471062833, 82.4443811, "285"],
[54.9482693333, 82.4618783667, "129"],
[54.9477489, 82.4616306833, "134"],
[54.94778825, 82.4623992333, "120"],
[54.9476318333, 82.4527723667, "205"],
[54.9487271, 82.47377555, "22"],
[54.9483278667, 82.4699560333, "64"],
[54.9505486833, 82.475507, "3"],
[54.9471956833, 82.45408385, "192"],
[54.9474878167, 82.4494432167, "241"],
[54.9465419167, 82.4494655333, "240"],
[54.8980432167, 82.4818800667, "20"],
[54.8980799167, 82.4813788167, "11"],
[54.8979071, 82.4814689833, "11A"],
[54.8976527, 82.4820540667, "10"],
[54.8978225833, 82.48198855, "12"],
[54.8980157833, 82.4823010833, "14"],
[54.8981133, 82.4825153333, "18"],
[54.8972657167, 82.48179755, "1"],
[54.8982001167, 82.4818174667, "22"],
[54.89831945, 82.48166055, "26"],
[54.8974300667, 82.4821601, "2"],
[54.8976037833, 82.4823142833, "6"],
[54.8975959167, 82.4816213167, "7"],
[54.8977532667, 82.48153515, "9"],
[54.8985379, 82.4825481, "24"],
[54.8966536667, 82.4826586833, "25A"],
[54.8984072, 82.48528765, "54A"],
[54.8960960167, 82.4812310167, "5"],
[54.8976620167, 82.4837889667, "38"],
[54.8957596833, 82.4808671833, "1"],
[54.896049, 82.4808353333, "1A"],
[54.89630705, 82.4808317833, "3"],
[54.8980094, 82.4834140167, "34"],
[54.89804835, 82.4835438167, "36"],
[54.8978337, 82.483244, "30"],
[54.8977234667, 82.4828271167, "26"],
[54.8974671333, 82.4832206833, "28"],
[54.89729555, 82.4826933167, "22"],
[54.8982734, 82.4859548167, "60"],
[54.8993387167, 82.4873577333, "76"],
[54.8971479167, 82.4808783833, "10"],
[54.8959557167, 82.48164725, "11"],
[54.8973392833, 82.4807942, "12"],
[54.8973916333, 82.4808756, "14"],
[54.8966921833, 82.4822478333, "21"],
[54.89642605, 82.4824713833, "23"],
[54.8967609167, 82.4825135833, "25"],
[54.8971820833, 82.4809704667, "16"],
[54.89693775, 82.4814169833, "18A"],
[54.8968612333, 82.4812093333, "18"],
[54.8968348, 82.4827666333, "27"],
[54.8969158833, 82.4829914167, "29"],
[54.8969838333, 82.4832029333, "31"],
[54.89760075, 82.4835397, "32"],
[54.8970568167, 82.48351615, "33"],
[54.8967365, 82.4807273, "2"],
[54.8979339167, 82.4848533, "44"],
[54.8967854, 82.4809565833, "4"],
[54.8958402333, 82.481278, "7"],
[54.8964383667, 82.4812642667, "9"],
[54.8980381167, 82.4851460667, "48"],
[54.8985301167, 82.4851492, "52"],
[54.8981529, 82.4855380167, "54"],
[54.8986448333, 82.4855899833, "56"],
[54.8985807833, 82.4870328333, "66"],
[54.8986987667, 82.4873079333, "68"],
[54.8987788167, 82.4875430667, "74"],
[54.89890085, 82.4879704667, "80"],
[54.8966231333, 82.4820502667, "17A"],
[54.8964502667, 82.4821239667, "17B"],
[54.896275, 82.48221365, "17"],
[54.8964864333, 82.4816180167, "15"],
[54.89829765, 82.4849233667, "48A"],
[54.8983503, 82.4862882, "62"],
[54.8963564333, 82.4817611, "15A"],
[54.8961816167, 82.4819250833, "15B"],
[54.8838324667, 82.4758307667, "1"],
[54.8836433833, 82.4758399333, "2"],
[54.8833977167, 82.47575535, "3"],
[54.8833314667, 82.4755896167, "4"],
[54.8834651, 82.4752073, "5A"],
[54.8833988833, 82.4754131, "5"],
[54.8836138833, 82.4754014333, "6"],
[54.88376315, 82.4754688833, "7"],
[54.8453489, 82.4520246, "12"],
[54.8453374333, 82.44998695, "30"],
[54.8456579, 82.4496963667, "33"],
[54.84527125, 82.4440318, "40"],
[54.8447595167, 82.4494073667, "38"],
[54.8453093333, 82.4489722667, "40"],
[54.8453195333, 82.4515149667, "16"],
[54.8833522167, 82.4662158833, "2/13"],
[54.8838213, 82.46524815, "10A"],
[54.88380855, 82.46613485, "7A"],
[54.8832769, 82.4662041167, "1/13"],
[54.88379275, 82.4654513833, "10"],
[54.88377815, 82.4658082667, "11"],
[54.88342395, 82.4662276833, "3/13"],
[54.883518, 82.4662264667, "4/13"],
[54.8836896667, 82.4656703833, "14"],
[54.8834471333, 82.4658730667, "15"],
[54.88344295, 82.46574735, "16"],
[54.8843819333, 82.4658316167, "1"],
[54.8844031667, 82.4655400167, "2"],
[54.8841441667, 82.4660546, "3A"],
[54.8841592333, 82.46611295, "3B"],
[54.8842008167, 82.4658206, "3"],
[54.8841960167, 82.4655438833, "4"],
[54.8840714, 82.4658066333, "5"],
[54.8840438, 82.4655440333, "6"],
[54.8839425167, 82.46582275, "7"],
[54.8839567167, 82.4654131167, "8"],
[54.8837516, 82.4660999833, "9"],
[54.883711, 82.4655393167, "12"],
[54.9413734667, 82.4995142833, "306"],
[54.9264553167, 82.4927426, "101"],
[54.9263942667, 82.495421, "93"],
[54.9367796667, 82.49396525, "218"],
[54.9306420333, 82.4927391167, "147"],
[54.9314740333, 82.4922045333, "156"],
[54.9346698333, 82.4939321167, "195"],
[54.9210469167, 82.49473535, "45"],
[54.9244517667, 82.4930819833, "76"],
[54.92482195, 82.4937379833, "85"],
[54.9278428667, 82.49133405, "116"],
[54.928097, 82.4920060333, "117"],
[54.9259406, 82.4921851333, "98"],
[54.9432639333, 82.5024320833, "321"],
[54.9478774167, 82.50590725, "360"],
[54.9006717, 82.3709368333, "24"],
[54.90793765, 82.3650150333, "121"],
[54.9056018833, 82.3671315333, "89"],
[54.9073516833, 82.3655189333, "119"],
[54.8986494833, 82.4611173667, "1"],
[54.8984617833, 82.4610480667, "3"],
[54.8983073667, 82.4609003333, "5"],
[54.8985554833, 82.4614893833, "2"],
[54.8983680333, 82.4614087, "4"],
[54.8981331333, 82.4608315333, "7"],
[54.8982140167, 82.4613434833, "6"],
[54.8979873167, 82.4611021667, "10"],
[54.8980203833, 82.4609355833, "9"],
[54.89806, 82.4612782333, "8"],
[54.9028616833, 82.4335225667, "29"],
[54.9031164833, 82.4331062, "27"],
[54.908270667, 82.4336130833, "43"],
[54.9018962667, 82.4342030167, "42"],
[54.9035645333, 82.4334544, "21"],
[54.8997075167, 82.4313605167, "63"],
[54.9028940667, 82.4339966333, "28"],
[54.90126025, 82.43430315, "54"],
[54.9009420667, 82.4335351333, "57"],
[54.8997543667, 82.4328163667, "67"],
[54.9042664833, 82.4334384833, "9"],
[54.9004958, 82.4365008, "56"],
[54.8999357667, 82.4364970167, "58"],
[54.9193787167, 82.4035627667, "29"],
[54.9187184, 82.40134295, "50"],
[54.91970595, 82.4043742667, "21"],
[54.93012645, 82.3979479333, "179"],
[54.9287776167, 82.3984838, "167"],
[54.9244404833, 82.40003235, "125"],
[54.9182969, 82.4015440667, "46"],
[54.9198358, 82.4009195, "62"],
[54.9214928833, 82.4003147333, "82"],
[54.9276005833, 82.3979560333, "156"],
[54.9090980833, 82.47152255, "112B"],
[54.9100087667, 82.47027605, "121A"],
[54.90817245, 82.47139345, "103"],
[54.90884805, 82.4719748, "108A"],
[54.9089414167, 82.4722395833, "108B"],
[54.9084711833, 82.47177935, "104"],
[54.90863345, 82.47171425, "106"],
[54.9083213167, 82.47131235, "105"],
[54.9090004, 82.472447, "108C"],
[54.9028464833, 82.4753390167, "26B"],
[54.9078277833, 82.4723944833, "4/96"],
[54.90357775, 82.4740898333, "36"],
[54.90385065, 82.473554, "35A"],
[54.9035803667, 82.47369605, "35"],
[54.90815455, 82.4719365833, "100"],
[54.91190955, 82.4702316833, "138"],
[54.90756, 82.4722275333, "7/96"],
[54.9089549167, 82.47103335, "111"],
[54.9044076167, 82.4737216, "42"],
[54.9011103, 82.4747561, "13"],
[54.9113504333, 82.46916605, "135B"],
[54.90916025, 82.4717170833, "112A"],
[54.9104814167, 82.4713397667, "124B"],
[54.9113419667, 82.4696552833, "133A"],
[54.9116247167, 82.4707302833, "134A"],
[54.9118128833, 82.4706304, "134B"],
[54.9117777333, 82.46919275, "139A"],
[54.91172915, 82.4689741333, "139B"],
[54.9091821167, 82.47238525, "110C"],
[54.9112748167, 82.46989875, "131A"],
[54.9112112333, 82.46968315, "131B"],
[54.9018407333, 82.474509, "17"],
[54.9021059167, 82.4747859167, "18"],
[54.9022214333, 82.4747533667, "20"],
[54.9021081667, 82.4743658667, "21"],
[54.9024045833, 82.4746604333, "22"],
[54.90227905, 82.4742904, "23"],
[54.9025434333, 82.4745909167, "24"],
[54.9033884667, 82.4737883, "33"],
[54.9029568833, 82.4739659833, "31"],
[54.90244755, 82.4742011333, "25"],
[54.9026128, 82.4741282667, "27"],
[54.9027832333, 82.4740469833, "29"],
[54.9027372833, 82.4744949833, "30"],
[54.9028963667, 82.4744151167, "32"],
[54.9039784167, 82.4735005167, "39"],
[54.9041466, 82.47341055, "41"],
[54.9043180167, 82.4733317667, "43"],
[54.9044306, 82.4732717, "45"],
[54.9002813333, 82.4746537333, "3A"],
[54.9003363333, 82.4746345833, "3B"],
[54.9003208833, 82.4742427, "3C"],
[54.9004106, 82.47457215, "3D"],
[54.9008182333, 82.4749564333, "7"],
[54.9008622667, 82.4745689333, "9A"],
[54.9087553333, 82.47168745, "108"],
[54.9087847167, 82.47111335, "109"],
[54.9090482, 82.4718688667, "110A"],
[54.9089821833, 82.47162705, "110"],
[54.9097564, 82.47064845, "117"],
[54.90991065, 82.4711398333, "118"],
[54.9098192, 82.4703204, "119A"],
[54.9100781833, 82.4710667, "120"],
[54.9102616, 82.4713288833, "120A"],
[54.91019675, 82.4704249667, "121"],
[54.9102786333, 82.47095955, "122"],
[54.91061325, 82.47114525, "124A"],
[54.9104595333, 82.4709259167, "124"],
[54.9103273167, 82.4703685833, "125"],
[54.9009658333, 82.47489005, "9"],
[54.9106314167, 82.47081795, "126"],
[54.9105098833, 82.4702934833, "127"],
[54.9115283, 82.47038715, "132"],
[54.9114078, 82.4698388833, "133"],
[54.9117353833, 82.4702887167, "136"],
[54.91165515, 82.4697282333, "137"],
[54.91209905, 82.4701214833, "140"],
[54.91192095, 82.46961505, "141"],
[54.91209585, 82.4695346667, "143"],
[54.91223925, 82.4694837833, "145"],
[54.9129544, 82.46972655, "148"],
[54.9127850833, 82.46918905, "149"],
[54.9131046167, 82.4696231333, "150"],
[54.9129241667, 82.4691591333, "151"],
[54.9133420333, 82.4695050167, "152"],
[54.9134355667, 82.4694691333, "154"],
[54.9136254167, 82.4688124833, "155"],
[54.9135736667, 82.4693978333, "156"],
[54.9137485167, 82.4693549667, "158"],
[54.9144754, 82.46902505, "164"],
[54.9147488833, 82.4695174667, "166"],
[54.9147467167, 82.4689613833, "168"],
[54.9053532, 82.4735344167, "44A"],
[54.9052717667, 82.4733045167, "44"],
[54.90506265, 82.4729767833, "49"],
[54.9052035667, 82.4729156167, "51"],
[54.9053496, 82.4728617833, "53"],
[54.9054862667, 82.47279975, "55"],
[54.9071557, 82.47249445, "88"],
[54.9011584833, 82.47587265, "10"],
[54.9012260167, 82.4757750333, "12"],
[54.9011779333, 82.47526505, "14"],
[54.9024628, 82.4750374833, "22A"],
[54.9024647, 82.4751844167, "22B"],
[54.9004774333, 82.4751149333, "1"],
[54.9028335, 82.4750389333, "28"],
[54.9004664333, 82.4755579667, "2"],
[54.9005692, 82.4755242167, "4"],
[54.9006539333, 82.4750368333, "5"],
[54.9010841833, 82.4755968, "8A"],
[54.9008984167, 82.4753584833, "8"],
[54.9091240667, 82.4721442833, "110B"],
[54.9097632833, 82.47034635, "117A"],
[54.9082253333, 82.4719109833, "102"],
[54.9114097833, 82.4693441333, "135A"],
[54.9112057333, 82.4692141667, "135C"],
[54.91167365, 82.4687884833, "139D"],
[54.9112668833, 82.4694056333, "135"],
[54.9111444667, 82.4690280333, "135D"],
[54.9115951667, 82.4692708167, "139"],
[54.9115359, 82.4690900833, "139C"],
[54.9106014, 82.4702607333, "129"],
[54.9076115833, 82.4723767833, "98"],
[54.9075872333, 82.4722996, "8/96"],
[54.9076397833, 82.4724662167, "10/96"],
[54.9076588167, 82.4725362667, "11/96"],
[54.9076818333, 82.47261165, "12/96"],
[54.90787275, 82.4725516833, "6/96"],
[54.9078548167, 82.4724749, "5/96"],
[54.9078033833, 82.47231415, "3/96"],
[54.9077763833, 82.4722320833, "2/96"],
[54.9077493833, 82.4721500167, "1/96"],
[54.9027466667, 82.4750991167, "26A"],
[54.9013304167, 82.4746607667, "13A"],
[54.9012675, 82.4744082333, "13B"],
[54.9010857333, 82.4744788167, "13C"],
[54.91033795, 82.47011845, "125A"],
[54.90225545, 82.4739976167, "23A"],
[54.9099696333, 82.4705395667, "119"],
[54.9152684167, 82.4687266333, "176"],
[54.8767274167, 82.4498122333, "31"],
[54.8753801, 82.4141292833, "347"],
[54.8749301667, 82.4229940833, "269"],
[54.8780543667, 82.4318462667, "2/193"],
[54.87844965, 82.4315496667, "4/193"],
[54.877916, 82.4313673167, "3/193"],
[54.8772684667, 82.4313525833, "1/193"],
[54.8745261, 82.41460525, "336"],
[54.8730149167, 82.4139278833, "348"],
[54.8749023333, 82.4133807833, "357"],
[54.8748893, 82.4158492, "331"],
[54.87500415, 82.4305876333, "199"],
[54.8762052667, 82.4298853667, "209"],
[54.876837, 82.4272319333, "231"],
[54.8750526167, 82.4337470333, "173"],
[54.8750786167, 82.4326617667, "185"],
[54.8765961833, 82.4422767333, "1/101"],
[54.8765928833, 82.44146825, "2/101"],
[54.8766094667, 82.4450663167, "1/75"],
[54.8751227667, 82.4479436, "47"],
[54.8785082667, 82.4463698333, "59"],
[54.8749291833, 82.42188625, "275"],
[54.8750447, 82.4367026, "145"],
[54.8746106333, 82.4284329, "218"],
[54.8745961333, 82.4294403, "210"],
[54.8729241167, 82.4301093, "204"],
[54.8730751833, 82.4315361667, "192"],
[54.8764695333, 82.4360706167, "2/151"],
[54.8750668667, 82.4352073833, "161"],
[54.8745754667, 82.4496806333, "32"],
[54.87504855, 82.4370912, "141"],
[54.8745623, 82.4221763333, "276"],
[54.8745616667, 82.4217338333, "278"],
[54.8749560667, 82.4206555833, "291"],
[54.87457185, 82.42039215, "292"],
[54.8749318, 82.4195155667, "297"],
[54.8749193167, 82.4189609333, "301"],
[54.8745523667, 82.4178998833, "314"],
[54.87555895, 82.4169412167, "317"],
[54.8727607, 82.4172541833, "320"],
[54.87489075, 82.41689625, "325"],
[54.8762137833, 82.4211919167, "283"],
[54.8773094667, 82.4190741833, "295"],
[54.8766782167, 82.4177899333, "307"],
[54.87495795, 82.4292900167, "211"],
[54.87496815, 82.4277122333, "229"],
[54.87496315, 82.4270601833, "235"],
[54.87495715, 82.4262284667, "243"],
[54.87466625, 82.4340618833, "166"],
[54.8731281333, 82.43353715, "176"],
[54.8746368667, 82.43285965, "180"],
[54.8746353667, 82.4320823333, "188"],
[54.8746651833, 82.43837135, "134"],
[54.8746581, 82.4361343333, "152"],
[54.8766056667, 82.4444213667, "2/75"],
[54.8750381333, 82.4425046833, "95"],
[54.8758251333, 82.4478232833, "49"],
[54.8751582, 82.4469793167, "51"],
[54.8771227333, 82.4464864167, "57"],
[54.8750768, 82.445912, "61"],
[54.8750693833, 82.4452335333, "71"],
[54.8765724333, 82.4321372667, "191"],
[54.876819, 82.4318101833, "1/191"],
[54.8750694, 82.4518701667, "15"],
[54.8750833, 82.4512497167, "21"],
[54.87511365, 82.449825667, "37"],
[54.8744741833, 82.4113393, "372"],
[54.87448925, 82.4111035167, "374"],
[54.8749085333, 82.4183780667, "309"],
[54.8748987, 82.4119560833, "371"],
[54.8754877, 82.4485419667, "43"],
[54.87489105, 82.4142969333, "1/347"],
[54.87509285, 82.4505922, "23"],
[54.8746456667, 82.4350032667, "162"],
[54.8817882333, 82.46555605, "1"],
[54.8817762333, 82.4657047, "2"],
[54.88177495, 82.4658300167, "3"],
[54.8818317167, 82.4659088333, "4"],
[54.8818769833, 82.4658514167, "5"],
[54.881892, 82.4657157833, "6"],
[54.8819030667, 82.4655528667, "7"],
[54.8249572667, 82.3822644167, "62C"],
[54.8241013167, 82.3830562833, "62B"],
[54.8235533667, 82.3836837833, "62A"],
[54.8232282333, 82.38113915, "42"],
[54.8216185167, 82.3801976167, "24"],
[54.8233693667, 82.3818881167, "50"],
[54.8238237167, 82.38163785, "48"],
[54.8223544167, 82.3807860167, "34"],
[54.8221907167, 82.38064385, "32"],
[54.798240833, 82.4757575167, "369"],
[54.7917070167, 82.4768378667, "371"],
[54.7976220833, 82.4791485667, "310"],
[54.8026816667, 82.4738649167, "241"],
[54.8063079833, 82.4719216833, "198"],
[54.8127222, 82.46321975, "88"],
[54.79851905, 82.4782582, "298"],
[54.7982161667, 82.4784413833, "300"],
[54.7979628667, 82.4785954333, "304"],
[54.7989472167, 82.4770213333, "289"],
[54.8124759, 82.46149895, "66"],
[54.80813105, 82.4692921667, "133"],
[54.80903515, 82.4695616333, "164"],
[54.81169535, 82.4617913167, "77"],
[54.7931904667, 82.4771456167, "359"],
[54.90154435, 82.4820577833, "17A"],
[54.9023211333, 82.4866221333, "50"],
[54.9029791167, 82.4860176833, "43"],
[54.9018640167, 82.4839159667, "29"],
[54.9017065667, 82.4845584, "32"],
[54.9013472667, 82.4832850333, "20"],
[54.9022597667, 82.4852180667, "37"],
[54.90235635, 82.4855437333, "39"],
[54.9020226167, 82.48626825, "48A"],
[54.90219835, 82.4862075833, "48"],
[54.9028144833, 82.4859300667, "41A"],
[54.9019145833, 82.4857036333, "38"],
[54.9012494167, 82.4836438333, "22A"],
[54.90117625, 82.4832889167, "20A"],
[54.9013004333, 82.4831083, "18A"],
[54.9018345667, 82.48310725, "23A"],
[54.9014717833, 82.4845211, "30A"],
[54.9011141833, 82.4813179833, "11"],
[54.9012595833, 82.4829706167, "18"],
[54.9012063333, 82.4815285167, "13"],
[54.90106015, 82.48224675, "14"],
[54.9014018333, 82.4835019, "22"],
[54.90164195, 82.4831019333, "23"],
[54.9014562667, 82.4837066, "24"],
[54.9017002833, 82.48331585, "25"],
[54.9013501333, 82.4820586167, "17"],
[54.9017979167, 82.48370115, "27A"],
[54.9017437333, 82.4834995, "27"],
[54.9015959833, 82.4841416, "28"],
[54.9016565333, 82.4843582167, "30"],
[54.9019526833, 82.4841925, "31"],
[54.90202855, 82.4844477667, "33"],
[54.9008982667, 82.4817133, "8"],
[54.9024487833, 82.4858792167, "41"],
[54.9020930667, 82.4858615167, "42"],
[54.9025991167, 82.4863993167, "49"],
[54.9021011667, 82.4846921667, "35"],
[54.9014189333, 82.4823503167, "19"],
[54.90126485, 82.4817892167, "15"],
[54.9015360333, 82.4839226833, "26"],
[54.83531625, 82.4933037333, "196"],
[54.8352276167, 82.4927147833, "195"],
[54.8360773, 82.4912368, "187"],
[54.8346867167, 82.49328105, "201"],
[54.82529725, 82.5052682333, "361"],
[54.8370500167, 82.4896684, "163"],
[54.8396963333, 82.4849568, "1/133"],
[54.8292152667, 82.4972928333, "281"],
[54.8293017833, 82.4982716333, "300"],
[54.8282765333, 82.4989055, "307"],
[54.8274501333, 82.5007519833, "333"],
[54.8273441167, 82.5024751333, "2/336"],
[54.8261453167, 82.5047067667, "360"],
[54.8301054, 82.4958695333, "275"],
[54.8271283667, 82.5028555, "1/336"],
[54.8369560667, 82.4905711833, "172"],
[54.81904615, 82.5025335167, "7/369"],
[54.8218408167, 82.50377335, "4/369"],
[54.8209456333, 82.5022760833, "6/369"],
[54.8208349667, 82.5044007, "5/369"],
[54.8238658, 82.50523275, "2/369"],
[54.8190694, 82.5003232333, "8/369"],
[54.8120237667, 82.5010552833, "10/369"],
[54.8118820833, 82.50392555, "11/369"],
[54.8356394, 82.4927849, "192"],
[54.8452920167, 82.4770441167, "6"],
[54.8332265167, 82.4939223333, "232"],
[54.8297708, 82.4960635, "253"],
[54.8393579167, 82.4857046667, "2/133"],
[54.83878395, 82.48766725, "142"],
[54.8379286333, 82.4890502, "152"],
[54.8364941, 82.4914751, "186"],
[54.8248432833, 82.5066992833, "369"],
[54.82553745, 82.5068898833, "380"],
[54.83202985, 82.4941239333, "240"],
[54.82194035, 82.5057576833, "3/369"],
[54.8227608167, 82.5063209333, "1/369"],
[54.8141088167, 82.5037792333, "9/369"],
[54.8382942833, 82.48852635, "148"],
[54.8603913833, 82.4492696, "57"],
[54.8592938167, 82.42099095, "308C"],
[54.85984295, 82.42067725, "308B"],
[54.8598229167, 82.4210151667, "308A"],
[54.8598344333, 82.3976947833, "508"],
[54.8603243333, 82.4140272833, "369"],
[54.8603184, 82.4123881167, "385"],
[54.86106375, 82.4477743833, "67"],
[54.861365, 82.4476857667, "73"],
[54.8613431833, 82.4479565167, "69"],
[54.86191185, 82.44788405, "71"],
[54.8603987333, 82.4502737667, "53"],
[54.86045645, 82.4319935167, "209"],
[54.8603551333, 82.4258720333, "263"],
[54.8599289833, 82.4315900833, "210"],
[54.8604198833, 82.4334522667, "195"],
[54.8627496167, 82.42078385, "309B"],
[54.8609723167, 82.4515878667, "37"],
[54.8603717833, 82.4514413333, "39"],
[54.8609809, 82.4517044667, "35"],
[54.86096795, 82.45250335, "27"],
[54.8604741333, 82.4530975833, "17"],
[54.8603852667, 82.451807, "33"],
[54.8572038, 82.42770555, "246"],
[54.8604631667, 82.4363373667, "171"],
[54.8591713833, 82.4484903833, "62"],
[54.8604119667, 82.4340429333, "191"],
[54.8603663667, 82.4354625167, "179"],
[54.8603935, 82.4373993667, "161"],
[54.8600009, 82.44318935, "108"],
[54.8599224167, 82.4265426167, "256"],
[54.8612047333, 82.4464131333, "81B"],
[54.8599028667, 82.4231039167, "288"],
[54.8602706, 82.4220058333, "295"],
[54.8602638667, 82.4191497333, "323"],
[54.8609657667, 82.4187969, "327"],
[54.8602931, 82.4179491333, "329"],
[54.8598848667, 82.4176532167, "338"],
[54.8632475167, 82.4173751333, "339"],
[54.8599251667, 82.4255647333, "1/264"],
[54.8599279667, 82.4253799333, "2/264"],
[54.86045495, 82.4383567333, "157"],
[54.8604267333, 82.4421660333, "113"],
[54.8617114333, 82.4414719167, "125"],
[54.8603943167, 82.43982245, "143"],
[54.8604978, 82.4449393667, "89"],
[54.8603957167, 82.4488193667, "59"],
[54.8599959167, 82.4481568167, "64"],
[54.8603463333, 82.4481201667, "65"],
[54.8603207833, 82.44708855, "75"],
[54.8617075, 82.4464497667, "85"],
[54.8603354667, 82.4458761167, "87"],
[54.8603924833, 82.4529279333, "21"],
[54.8603805, 82.4522459167, "31"],
[54.8603894333, 82.4465241, "81"],
[54.8624513667, 82.4464558667, "2/85"],
[54.8603426, 82.42038605, "309A"],
[54.8597382167, 82.4030150833, "468"],
[54.8600008333, 82.4468853333, "78"],
[54.8600151833, 82.4476529333, "70"],
[54.8619444167, 82.4473194667, "77"],
[54.8604090333, 82.4206673167, "309"],
[54.8599482667, 82.4450833833, "90"],
[54.8599667333, 82.4439503167, "102"],
[54.8599639167, 82.4443829333, "98"],
[54.8604016667, 82.4435244167, "107"],
[54.8602872667, 82.4157777167, "357C"],
[54.8619551667, 82.4154903667, "357B"],
[54.8602759333, 82.41535695, "357"],
[54.8599460833, 82.4464074167, "82"],
[54.8585100167, 82.4461918667, "84"],
[54.8604238667, 82.4437588667, "105"],
[54.86030515, 82.4229068167, "289"],
[54.9165466667, 82.5400699667, "47"],
[54.9163835, 82.5395208667, "52"],
[54.9162024833, 82.5415235333, "4/35"],
[54.9138618, 82.5389959167, "20"],
[54.9147363, 82.5367299167, "4"],
[54.9171924833, 82.5398619667, "53"],
[54.9156216333, 82.5400467167, "1/35"],
[54.9156090167, 82.5406467667, "2/35"],
[54.9155483, 82.54130355, "3/35"],
[54.9161911333, 82.5412111333, "5/35"],
[54.9177019333, 82.5406090667, "57"],
[54.9172073167, 82.5390771667, "56"],
[54.8413934333, 82.3669168333, "185"],
[54.8417850333, 82.3689200833, "199"],
[54.8428339667, 82.3706989, "216"],
[54.8416074, 82.36479145, "164"],
[54.8409904167, 82.3645986833, "157"],
[54.84092815, 82.3644066167, "161"],
[54.8749487833, 82.4757354167, "4"],
[54.8748824667, 82.4752927333, "3"],
[54.8746354, 82.475246, "5"],
[54.8742075167, 82.4755986333, "10"],
[54.8743622667, 82.4759894667, "8A"],
[54.8744567667, 82.4756695333, "8"],
[54.8748683833, 82.4760352167, "4A"],
[54.8742254333, 82.47601205, "10A"],
[54.8747158167, 82.4760297167, "6A"],
[54.8746737833, 82.4757186333, "6"],
[54.9465236167, 82.3809737667, "672"],
[54.9005455, 82.4730509333, "22"],
[54.9003672167, 82.4684980833, "17"],
[54.9003614667, 82.4682696667, "13"],
[54.9009926333, 82.4714326, "18B"],
[54.9004931, 82.4733237333, "24"],
[54.90023555, 82.4663222333, "3"],
[54.9003731333, 82.4738848333, "30"],
[54.90041915, 82.4736641333, "28A"],
[54.9008516833, 82.47143275, "18A"],
[54.9009989333, 82.4716885333, "18C"],
[54.9011166833, 82.4715942833, "18D"],
[54.9013468667, 82.4716314833, "18E"],
[54.9013142333, 82.4713999333, "18F"],
[54.9007320667, 82.4678888833, "12"],
[54.9007490333, 82.4682728833, "14"],
[54.9002906, 82.4672436333, "11"],
[54.9005921667, 82.4728228833, "20"],
[54.9012265333, 82.4713549, "18G"],
[54.8998487333, 82.4663062167, "1"],
[54.9004667833, 82.4734721, "26"],
[54.9007287833, 82.4668388, "4"],
[54.9002529667, 82.4665572, "5"],
[54.9002680333, 82.4668009667, "7"],
[54.9002738833, 82.4670198667, "9"],
[54.90052665, 82.4737441167, "28B"],
[54.9202440833, 82.4647199333, "59"],
[54.9186491, 82.4631960333, "74"],
[54.9197376, 82.46404755, "63"],
[54.9209585333, 82.4715133667, "31"],
[54.92198325, 82.4719067667, "32"],
[54.9200168333, 82.4637374167, "64"],
[54.9199907667, 82.4714465333, "9"],
[54.91941015, 82.4649217833, "65"],
[54.9196411667, 82.4633694333, "66"],
[54.91916365, 82.4639929833, "67A"],
[54.9194144667, 82.4637018833, "67"],
[54.9193556833, 82.4631293833, "70"],
[54.9191286667, 82.4630976, "72"],
[54.9189485833, 82.4635427667, "69"],
[54.9201641167, 82.4662894167, "55"],
[54.9211940333, 82.4656174833, "56A"],
[54.920671, 82.4657966667, "56"],
[54.92006415, 82.4658042, "57A"],
[54.9213706, 82.4727426833, "23"],
[54.9214441667, 82.4732278667, "24"],
[54.9202821667, 82.4732763833, "18"],
[54.9204884667, 82.4729263, "19"],
[54.9211967, 82.47098555, "33"],
[54.92094835, 82.4706909167, "35"],
[54.9219078167, 82.47147535, "34"],
[54.9197843667, 82.46309625, "68"],
[54.9210935333, 82.46484215, "60A"],
[54.9212236167, 82.4704147167, "40"],
[54.9197908, 82.4659149333, "55A"],
[54.92033405, 82.4655102, "57"],
[54.9211895167, 82.46547285, "58A"],
[54.9207404, 82.46524515, "58"],
[54.91857275, 82.4635986167, "71"],
[54.9182674667, 82.46367495, "73"],
[54.9195246333, 82.4715611, "11"],
[54.9216761833, 82.4729861167, "26"],
[54.92162375, 82.4721619667, "27"],
[54.9218544, 82.4726169833, "28"],
[54.9215389333, 82.4715153167, "29"],
[54.9219467167, 82.4722808333, "30"],
[54.9193754, 82.4726740833, "12"],
[54.9195867667, 82.4721921667, "13"],
[54.9196743333, 82.4735581167, "14A"],
[54.91978385, 82.4729767167, "14"],
[54.9200549833, 82.4726106667, "15"],
[54.9197512333, 82.4737709, "16"],
[54.9204467, 82.4722458667, "17"],
[54.9199559, 82.4736553667, "18A"],
[54.9193368833, 82.4700432833, "1"],
[54.9218013667, 82.4711677833, "36"],
[54.9204076, 82.4708148667, "37"],
[54.928217833, 82.4702188667, "38A"],
[54.9215826, 82.4708205333, "38"],
[54.9207000333, 82.4703961167, "39"],
[54.9205687167, 82.4700339833, "41"],
[54.9208976, 82.46987095, "42"],
[54.92033355, 82.4687946, "45"],
[54.91982325, 82.4679912667, "47A"],
[54.9209613833, 82.4677278167, "48A"],
[54.92131875, 82.4676346167, "48B"],
[54.9205986, 82.4680208, "48"],
[54.9196399667, 82.4679596667, "49B"],
[54.9202544833, 82.4681937167, "47"],
[54.9198937833, 82.4678851833, "49A"],
[54.9205374667, 82.46738275, "50"],
[54.9213241, 82.4675107, "50B"],
[54.9201188667, 82.4669429, "51"],
[54.92103205, 82.4665559333, "52A"],
[54.9205449167, 82.4668373833, "52"],
[54.9198923833, 82.46667, "53"],
[54.9210808167, 82.4664227833, "54A"],
[54.920561, 82.4662841333, "54"],
[54.91946705, 82.4707291667, "5"],
[54.9193920833, 82.47035955, "3"],
[54.9195288167, 82.4710633833, "7"],
[54.92069515, 82.4648828167, "60"],
[54.9209773667, 82.4675400333, "50A"],
[54.9201842667, 82.46752845, "49"],
[54.9200461167, 82.4643875333, "61"],
[54.9205402833, 82.4644506333, "62"],
[54.9196651333, 82.4646621833, "63A"],
[54.9211008833, 82.4733943, "22"],
[54.9207025167, 82.4734697333, "20"],
[54.9209406667, 82.47297795, "21"],
[54.9211156333, 82.4720907167, "25"],
[54.9221545333, 82.4731278833, "26A"],
[54.8946718167, 82.4691448667, "53"],
[54.8945620667, 82.46918055, "55"],
[54.8942623667, 82.4697152833, "52"],
[54.894203, 82.4688735167, "65"],
[54.89425415, 82.4689361333, "63"],
[54.89414905, 82.4688349167, "67"],
[54.8939181333, 82.4694227167, "64"],
[54.8938391333, 82.4693460667, "66"],
[54.8907021167, 82.4667148333, "93"],
[54.8906039, 82.4666683167, "95"],
[54.8902027167, 82.4664942833, "103"],
[54.8905652, 82.4673196167, "92"],
[54.8898694, 82.4663493333, "107"],
[54.8897077333, 82.4662881167, "113"],
[54.8897784833, 82.4663228, "111"],
[54.8956830333, 82.4710189333, "32"],
[54.8955352667, 82.4709092833, "36"],
[54.8954734333, 82.4708266833, "38"],
[54.8960418333, 82.47138995, "28"],
[54.8820345667, 82.46329545, "3/201"],
[54.8822174333, 82.46335335, "1/201"],
[54.8821085167, 82.4633248, "2/201"],
[54.8823766667, 82.4634171667, "197"],
[54.8841371, 82.46403415, "82A"],
[54.8841525333, 82.4636656, "82B"],
[54.8864762667, 82.4645354333, "151"],
[54.8863782833, 82.4644388833, "153"],
[54.8862153, 82.4648985833, "155"],
[54.8860901, 82.4648409833, "157"],
[54.8880628167, 82.4656834833, "133"],
[54.8878619333, 82.4655976667, "135"],
[54.8906979667, 82.4673655, "90"],
[54.8907991, 82.4667608667, "91"],
[54.8961849167, 82.4707743833, "25"],
[54.8836823667, 82.4638652167, "181"],
[54.8836385667, 82.4632253833, "183"],
[54.8838402, 82.4639201167, "179"],
[54.8982437333, 82.4734017333, "1"],
[54.8849776167, 82.46438955, "171"],
[54.8843719833, 82.4641355167, "173"],
[54.8839963167, 82.4632512833, "177"],
[54.88393085, 82.4634884, "179B"],
[54.8837384333, 82.4634720333, "181A"],
[54.8834786833, 82.4638174667, "185"],
[54.8834804667, 82.46322915, "187"],
[54.8833056667, 82.4637555833, "189"],
[54.88310485, 82.4633649667, "191A"],
[54.8831340833, 82.4636871, "191"],
[54.8830253167, 82.4636718333, "193"],
[54.8819504, 82.4632695667, "203"],
[54.88170725, 82.4631031, "205"],
[54.88149825, 82.4630156833, "207"],
[54.8813178333, 82.4626260667, "209A"],
[54.8813002167, 82.4629425167, "209"],
[54.8810862833, 82.4628550167, "211"],
[54.8884475, 82.46494685, "125A"],
[54.88836565, 82.4649932, "127A"],
[54.88680255, 82.4645032, "145"],
[54.8866910333, 82.4647031667, "147A"],
[54.8863981167, 82.4649715167, "149"],
[54.8859491, 82.4647828333, "159"],
[54.8857348333, 82.4647021333, "161"],
[54.8856289833, 82.4642462833, "163"],
[54.8854787333, 82.4646066833, "165"],
[54.8853169667, 82.4645344833, "167"],
[54.8851657167, 82.4644626667, "169"],
[54.89008265, 82.4664379167, "105"],
[54.8888476167, 82.4659953167, "117"],
[54.88862475, 82.4659086167, "121"],
[54.8884613833, 82.4658299, "123"],
[54.8884445167, 82.4652906, "125"],
[54.8883496833, 82.46527395, "127"],
[54.8882554833, 82.46575415, "129"],
[54.8881798833, 82.4652017833, "131"],
[54.8876298667, 82.4655107667, "137"],
[54.8874722667, 82.4654312667, "139"],
[54.8870441833, 82.4652550333, "141"],
[54.8868197, 82.46516795, "143"],
[54.8865865, 82.46503135, "147"],
[54.8944378167, 82.4698605333, "48"],
[54.8943299667, 82.4697972167, "50"],
[54.8946586167, 82.46927655, "51"],
[54.8942089833, 82.4696627, "54"],
[54.89410215, 82.46963495, "56"],
[54.8944861833, 82.4691251333, "57"],
[54.89410185, 82.4695671167, "58"],
[54.89440395, 82.4690316833, "59"],
[54.8940363833, 82.4695254833, "60"],
[54.8943071333, 82.4689793333, "61"],
[54.8939694333, 82.4694826, "62"],
[54.8937483667, 82.4692441333, "68"],
[54.8940153, 82.4687127667, "69"],
[54.8936944333, 82.4691774333, "70"],
[54.8939444833, 82.4686454167, "71"],
[54.8914311167, 82.4676565833, "78"],
[54.8914605833, 82.4668025833, "81"],
[54.8911125833, 82.467531, "82"],
[54.8913374667, 82.46691925, "83"],
[54.8909541667, 82.4674899167, "84"],
[54.8912424167, 82.4668760167, "85"],
[54.89086865, 82.4674540833, "86"],
[54.8911290333, 82.46682535, "87"],
[54.8908065333, 82.4674188167, "88"],
[54.8909961333, 82.4667623333, "89"],
[54.89043345, 82.4672657667, "98"],
[54.8976105333, 82.47313585, "10"],
[54.8975240667, 82.47213955, "17"],
[54.8964341, 82.4719897, "18"],
[54.8965768167, 82.4718193667, "20"],
[54.8964536167, 82.47098525, "21"],
[54.8965168, 82.4717821667, "22"],
[54.8963066833, 82.4708868167, "23"],
[54.8964117, 82.4716877833, "24"],
[54.8973729833, 82.4718744167, "19"],
[54.8961056167, 82.4707024167, "27"],
[54.89606105, 82.4706588333, "29"],
[54.8957499, 82.4710900333, "30"],
[54.8960081167, 82.4706084667, "31"],
[54.89595535, 82.4705515167, "33"],
[54.8962650667, 82.4715582333, "26"],
[54.8977395833, 82.4736163833, "2A"],
[54.8976182167, 82.4734736333, "2"],
[54.8950879167, 82.4697355, "49"],
[54.8953451167, 82.47080125, "40"],
[54.8952480833, 82.4706864833, "42"],
[54.8953311333, 82.4699905167, "43"],
[54.8951690167, 82.4705682833, "44"],
[54.8952598667, 82.4699087, "45"],
[54.8951447333, 82.4705209333, "46"],
[54.8951409333, 82.4698058667, "47"],
[54.8954689333, 82.4701014167, "41A"],
[54.8958601667, 82.4704608833, "35"],
[54.8957632833, 82.4703618, "37"],
[54.89565655, 82.4702728333, "39"],
[54.8955528, 82.4701858833, "41"],
[54.8976127167, 82.4736873167, "4A"],
[54.8974748, 82.4735857667, "4"],
[54.8973855833, 82.4735356667, "6"],
[54.8974473167, 82.4733615667, "8"],
[54.8896038, 82.4662530833, "115"],
[54.8938700833, 82.46857325, "73"],
[54.8913213333, 82.4676180667, "80"],
[54.89351535, 82.4690702167, "76"],
[54.8936501, 82.4683802833, "77"],
[54.8937599333, 82.4684853667, "75"],
[54.8935794833, 82.4691255, "72"],
[54.88384375, 82.4636547333, "179A"],
[54.8877088, 82.4661684833, "104"],
[54.8853223833, 82.4655525667, "128B"],
[54.88438085, 82.4648718667, "136C"],
[54.8841924667, 82.46482515, "138"],
[54.8840040333, 82.4647229667, "140"],
[54.8838259833, 82.4646471667, "142"],
[54.8836846833, 82.4645814167, "144"],
[54.8833978167, 82.4647726167, "146A"],
[54.88347465, 82.46450515, "146"],
[54.8832495667, 82.4646684333, "148B"],
[54.8833107333, 82.4644183167, "148A"],
[54.8830987333, 82.4643600833, "150"],
[54.88243095, 82.4641342, "152"],
[54.8822347333, 82.4643721667, "154A"],
[54.88231865, 82.4640810833, "154"],
[54.8820192, 82.4644994833, "156"],
[54.8820541833, 82.46428995, "158A"],
[54.8821268, 82.4640207, "158"],
[54.88190465, 82.4639371333, "160"],
[54.8817260167, 82.4638787833, "162"],
[54.8814407667, 82.4640942167, "164A"],
[54.8815740333, 82.46375875, "164"],
[54.8814061667, 82.4637101333, "166"],
[54.8812219167, 82.4636397667, "168"],
[54.8810714, 82.4635707167, "170"],
[54.8849612333, 82.4651687333, "134"],
[54.8867657833, 82.46587165, "116"],
[54.8873525667, 82.4663687, "108A"],
[54.8875141333, 82.46643145, "108B"],
[54.88740205, 82.4660429667, "108"],
[54.8872605, 82.46600665, "110"],
[54.8870516667, 82.4659278333, "114"],
[54.8859261833, 82.4657479333, "122A"],
[54.8859050667, 82.4659105167, "122B"],
[54.8859588, 82.4655614, "122"],
[54.88575615, 82.4657199833, "124A"],
[54.8857864167, 82.4655019333, "124"],
[54.8855956333, 82.46541875, "126"],
[54.8854599, 82.4652737833, "128"],
[54.8852678333, 82.46529905, "130"],
[54.8850946667, 82.4652269667, "132"],
[54.8878558833, 82.4662192833, "100"],
[54.88434005, 82.4648704833, "136B"],
[54.88430585, 82.4648585667, "136A"],
[54.9102085667, 82.47267125, "50B"],
[54.9116658, 82.4774299167, "86A"],
[54.91171815, 82.4771741167, "82A"],
[54.90942125, 82.47189105, "37"],
[54.91030625, 82.47526205, "63B"],
[54.9104127167, 82.4752166, "63A"],
[54.9095648833, 82.47290545, "49A"],
[54.9093032333, 82.4714794833, "35A"],
[54.90934235, 82.47164185, "35B"],
[54.9093857333, 82.4728978167, "47B"],
[54.9095356333, 82.4723232833, "43"],
[54.9094703333, 82.4721117667, "39"],
[54.9096594333, 82.4715342167, "40"],
[54.9080098833, 82.4672010667, "5"],
[54.9083293833, 82.4682696833, "13"],
[54.9089423167, 82.4690827667, "20"],
[54.9089409167, 82.4702961167, "29"],
[54.9081540667, 82.46658445, "2"],
[54.9097415167, 82.478228833, "42"],
[54.9101694333, 82.4746051167, "57"],
[54.9080884, 82.4674672833, "7"],
[54.91215875, 82.4797119167, "102"],
[54.9118344667, 82.4799542, "103"],
[54.9106944, 82.4744461, "62A"],
[54.9113962667, 82.4772112333, "82"],
[54.90982995, 82.4733563, "51A"],
[54.9115914833, 82.4801362333, "107A"],
[54.9092558833, 82.4696357, "26B"],
[54.91002055, 82.4726635167, "50A"],
[54.90847515, 82.46755925, "10"],
[54.9082532667, 82.4680019333, "11"],
[54.9088822833, 82.4688571833, "18"],
[54.9086208167, 82.4692152333, "19"],
[54.9085374333, 82.4677686333, "12"],
[54.9086063833, 82.4679739333, "14"],
[54.9086596833, 82.4681819, "16"],
[54.9086889667, 82.4694297167, "21"],
[54.9089948667, 82.4692835833, "22"],
[54.9087513667, 82.4696475333, "23"],
[54.9090557667, 82.4694965167, "24"],
[54.9088116333, 82.4698680667, "25"],
[54.9091091, 82.46969345, "26"],
[54.907833, 82.4666559167, "1"],
[54.9091789833, 82.4699557667, "28"],
[54.9096087, 82.4713450667, "38"],
[54.9092433833, 82.4701392333, "30"],
[54.9090019833, 82.47051235, "31"],
[54.9093068333, 82.4703555833, "32"],
[54.9090940833, 82.4707707667, "33"],
[54.90938145, 82.4705582833, "34"],
[54.9094346667, 82.4707651333, "36"],
[54.9088761167, 82.47007805, "27"],
[54.9098069333, 82.4719604833, "44"],
[54.9098796833, 82.4721707667, "46"],
[54.909607, 82.4725725667, "45"],
[54.90920615, 82.4729688333, "47A"],
[54.9093402667, 82.4728171, "47"],
[54.9099493833, 82.4724105167, "48"],
[54.9096936333, 82.47284265, "49"],
[54.9079234833, 82.4669311833, "3"],
[54.9082463667, 82.4668155333, "4"],
[54.9097714167, 82.4731308333, "51"],
[54.9100506833, 82.4729631167, "52"],
[54.9101362833, 82.473234, "54"],
[54.9105130333, 82.4743347667, "60"],
[54.91028125, 82.4747888167, "59"],
[54.9105830167, 82.4745966167, "62"],
[54.9106531, 82.4748493333, "64"],
[54.90835855, 82.4671917333, "8"],
[54.9081653833, 82.4677261, "9"],
[54.9120752833, 82.4794866167, "100"],
[54.9117925167, 82.47970425, "101"],
[54.91190545, 82.4801769333, "105"],
[54.9122550333, 82.4799224833, "106"],
[54.9116940333, 82.48024145, "107"],
[54.9124476, 82.4801052833, "108"],
[54.9117246833, 82.4803671833, "109"],
[54.9103405167, 82.4750005667, "61"],
[54.9104726833, 82.4754203667, "65"],
[54.9107200333, 82.47506155, "66"],
[54.91053305, 82.4756331, "67"],
[54.9111229833, 82.476363, "74"],
[54.9114657833, 82.4764926, "76A"],
[54.911183, 82.4765541167, "76"],
[54.91150505, 82.47660575, "78A"],
[54.9112499833, 82.4767965667, "78"],
[54.9115982333, 82.4769201167, "80A"],
[54.911382167, 82.4769843333, "80"],
[54.91152935, 82.4777795, "88"],
[54.9117877, 82.4784990667, "92"],
[54.9118644667, 82.4787878833, "94"],
[54.9121825833, 82.4787955833, "96A"],
[54.9119467333, 82.47904265, "96"],
[54.9119913167, 82.4792895833, "98"],
[54.9117365667, 82.47948695, "99"],
[54.9107912667, 82.4752822833, "68"],
[54.9108477833, 82.4754937167, "70"],
[54.9118233, 82.4773533, "86B"],
[54.9119954167, 82.47727035, "86C"],
[54.9115303833, 82.4774913167, "86"],
[54.9082149, 82.4684349833, "13A"],
[54.8870698333, 82.4663411167, "1-13"],
[54.8871554667, 82.4663601, "2-12"],
[54.9016082667, 82.4806621, "30"],
[54.9010984667, 82.4803028833, "22"],
[54.9012443833, 82.4808339333, "24"],
[54.9013056667, 82.4802206, "26"],
[54.90149895, 82.4805675833, "28"],
[54.9015629833, 82.4800562667, "32"],
[54.90147835, 82.4797437167, "45"],
[54.8996289167, 82.4806158667, "2A"],
[54.89956085, 82.4797871333, "11"],
[54.9009366167, 82.4793407667, "37"],
[54.9010581667, 82.4795131167, "39"],
[54.8992862833, 82.4802488833, "5"],
[54.90020145, 82.4797472, "10"],
[54.9003469333, 82.47964355, "12"],
[54.89972725, 82.47967295, "13"],
[54.9006396, 82.4794276, "14"],
[54.8998769167, 82.47947625, "15"],
[54.9007610667, 82.4795863833, "16"],
[54.9008528833, 82.47974655, "18"],
[54.9009693167, 82.4799194, "20"],
[54.90002065, 82.47947515, "17"],
[54.9001685333, 82.4793572, "19"],
[54.8993512667, 82.4806693, "1"],
[54.9003158833, 82.479241, "21"],
[54.9004667167, 82.4791244167, "23"],
[54.9006037, 82.4790302167, "25"],
[54.90070445, 82.4786061667, "27"],
[54.9007410667, 82.4788370167, "29"],
[54.9008196333, 82.4791513333, "31"],
[54.901124, 82.4788828667, "33"],
[54.90119195, 82.4790490333, "35"],
[54.9013381833, 82.4794026, "41"],
[54.8997734, 82.4805030333, "2"],
[54.8992978333, 82.4804472333, "3"],
[54.9012097667, 82.4797523667, "43"],
[54.8996789, 82.48033335, "4"],
[54.8998323667, 82.4800290167, "6"],
[54.8993387167, 82.4800615833, "7"],
[54.9000414667, 82.4798654, "8"],
[54.8994266333, 82.47991435, "9"],
[54.8172086167, 82.36975015, "17"],
[54.8189982167, 82.3714596333, "28C"],
[54.8174889333, 82.3716284333, "35"],
[54.8180339667, 82.3717238667, "36"],
[54.8172767, 82.3702897333, "25"],
[54.8183033167, 82.3704190333, "28A"],
[54.8177806167, 82.3709889833, "30"],
[54.8184724667, 82.3714858167, "34"],
[54.8172573833, 82.3723560333, "37"],
[54.882974333, 82.3697317, "18"],
[54.8189201833, 82.3708153, "28B"],
[54.8170975, 82.3688759833, "7"],
[54.8174008333, 82.3711639167, "31"],
[54.8177271333, 82.3719905167, "39"],
[54.9105104667, 82.4696305667, "29"],
[54.9105738333, 82.4698784833, "33"],
[54.9119496333, 82.4744651, "75"],
[54.9124263667, 82.4747625167, "76"],
[54.9120037833, 82.47464375, "77A"],
[54.9103653167, 82.4676619667, "20"],
[54.9108393333, 82.4707173, "41"],
[54.91176765, 82.4719875333, "58A"],
[54.9116183, 82.4720772, "58"],
[54.9128712, 82.4761248167, "86"],
[54.9124839333, 82.47629265, "85"],
[54.9104650167, 82.4694600667, "27"],
[54.9109299, 82.4697178333, "40"],
[54.9109971667, 82.4699570333, "42"],
[54.9097695, 82.4672281333, "11"],
[54.9100539667, 82.4665771, "10"],
[54.91041835, 82.4666636, "12A"],
[54.9101176333, 82.4667979833, "12"],
[54.90983315, 82.4674340333, "13"],
[54.9104875, 82.4669176667, "14A"],
[54.9101736833, 82.4670051, "14"],
[54.9098833833, 82.46762845, "15"],
[54.9102367667, 82.4672218833, "16"],
[54.9099549667, 82.46780795, "17"],
[54.9105899, 82.46737165, "18A"],
[54.9102941833, 82.4674259333, "18"],
[54.91020335, 82.4685710333, "21"],
[54.9102757167, 82.4688396333, "23"],
[54.9105438167, 82.46821955, "22"],
[54.9105772667, 82.4685320333, "26"],
[54.9104076167, 82.4692623833, "25"],
[54.9094199667, 82.4660506333, "1"],
[54.9106404167, 82.4687469667, "28"],
[54.9107060667, 82.4689637167, "30"],
[54.9103114167, 82.4698414333, "31"],
[54.9110137167, 82.4690528333, "34A"],
[54.9107613667, 82.4691689333, "34"],
[54.91081495, 82.4693474, "36A"],
[54.9110468333, 82.46924275, "36B"],
[54.9108736, 82.4695344167, "38A"],
[54.9111242, 82.46941945, "38B"],
[54.9098216167, 82.4658393167, "2"],
[54.91088605, 82.4708887833, "43"],
[54.9112278167, 82.4705661167, "44"],
[54.9109336667, 82.47106555, "45"],
[54.91129165, 82.4707536333, "46"],
[54.9109882333, 82.4712586667, "47"],
[54.9113449167, 82.47095045, "48"],
[54.9110579667, 82.4714307833, "49"],
[54.9094612667, 82.4662574167, "3"],
[54.9114052833, 82.4711525333, "50"],
[54.9114515333, 82.4713499667, "52"],
[54.9111246333, 82.47187335, "51"],
[54.9117082, 82.4723085667, "60"],
[54.918221667, 82.4724906333, "62"],
[54.91170015, 82.47359465, "63"],
[54.9182395, 82.4737979833, "65"],
[54.9120630333, 82.4735410667, "66A"],
[54.9122263, 82.47353625, "66B"],
[54.9118108167, 82.4740034667, "67"],
[54.9113339, 82.4743958833, "69"],
[54.90952435, 82.4664596667, "5"],
[54.90970875, 82.4670344667, "9"],
[54.91152875, 82.4743488, "71"],
[54.9123023, 82.47433295, "72"],
[54.9118344167, 82.4742989833, "73A"],
[54.9118896667, 82.4742717333, "73"],
[54.9123685833, 82.4745438, "74"],
[54.91204505, 82.4747885167, "77B"],
[54.9124726167, 82.4749395667, "78"],
[54.9120965167, 82.47493145, "79"],
[54.9099235167, 82.46615755, "6"],
[54.9099866, 82.4663651333, "8"],
[54.9126461, 82.4754722667, "80"],
[54.9123464833, 82.4758373333, "81"],
[54.9124222167, 82.4761109333, "83"],
[54.9129424833, 82.47629755, "88A"],
[54.91334525, 82.4762585833, "90A"],
[54.9134976667, 82.4761915, "90B"],
[54.9133118333, 82.47629305, "90"],
[54.9127142, 82.4769782833, "87"],
[54.9127630833, 82.4771701667, "89"],
[54.9131761, 82.47644985, "92A"],
[54.9131949667, 82.47653455, "92B"],
[54.9130077167, 82.4766852167, "94"],
[54.9131084667, 82.4770053833, "96"],
[54.9133594333, 82.4770784833, "98"],
[54.91309155, 82.4760073833, "86B"],
[54.9127336333, 82.4757125833, "82"],
[54.9128152667, 82.4759342833, "84"],
[54.9129075333, 82.4763391333, "88"],
[54.8906112, 82.4636290667, "8"],
[54.8906010667, 82.4641357833, "1A"],
[54.8905902667, 82.4639329, "4"],
[54.8905940833, 82.4640698, "2"],
[54.8906316167, 82.4632836667, "13"],
[54.8907058, 82.4633735833, "17"],
[54.8905923, 82.4640024833, "3"],
[54.8907071833, 82.4634437667, "18"],
[54.8906947667, 82.4635948667, "20"],
[54.8906874333, 82.4636836833, "21"],
[54.890681, 82.4637655167, "22"],
[54.8906765333, 82.4638413833, "23"],
[54.8906641, 82.4639166833, "24"],
[54.8906549, 82.4639912667, "25"],
[54.8906532333, 82.4640676833, "26"],
[54.8906518667, 82.46414095, "27"],
[54.8906011167, 82.4638605167, "5"],
[54.8906079667, 82.4637939167, "6"],
[54.8906326167, 82.4634340333, "11"],
[54.8906169667, 82.4635610833, "9"],
[54.8906290333, 82.46349725, "10"],
[54.8906352333, 82.4633559333, "12"],
[54.8906300833, 82.4632139167, "14"],
[54.8906897167, 82.4632274, "15"],
[54.8905997667, 82.46420885, "1"],
[54.8906515667, 82.4642292333, "28"],
[54.8905993833, 82.4637104667, "7"],
[54.8905424667, 82.4641317333, "1B"],
[54.8906997833, 82.4632963667, "16"],
[54.89069985, 82.4635183333, "19"],
[54.82488245, 82.3937114333, "107"],
[54.82511735, 82.3936415, "105"],
[54.8241600833, 82.3938937, "115"],
[54.8257229, 82.3934403167, "95"],
[54.8311935833, 82.39119285, "34"],
[54.8312837167, 82.3938057, "44"],
[54.8302991667, 82.3911272833, "39"],
[54.8298778833, 82.38838305, "33"],
[54.8260734, 82.3947714167, "94C"],
[54.8263358833, 82.3938421667, "94A"],
[54.8279937667, 82.394307, "72C"],
[54.8246244833, 82.3942836667, "110"],
[54.82928665, 82.3931185833, "58"],
[54.8239608833, 82.3939572, "117"],
[54.8307863167, 82.3929875333, "46B"],
[54.83183475, 82.3898969167, "19"],
[54.82823865, 82.3933544333, "72A"],
[54.82829215, 82.3941929833, "72B"],
[54.8278144167, 82.3934866833, "72D"],
[54.8263441833, 82.3946904167, "94B"],
[54.8258577167, 82.3939724833, "94D"],
[54.8252182667, 82.3953295167, "108"],
[54.8301352667, 82.3922486833, "46A"],
[54.8325430167, 82.3898667667, "14"],
[54.8327221167, 82.3897138833, "12"],
[54.91482215, 82.4749911167, "3"],
[54.9154439833, 82.4755851833, "12"],
[54.9151334833, 82.4758027, "13"],
[54.9152983167, 82.4757077333, "14"],
[54.9150524833, 82.4746568833, "2"],
[54.9147571833, 82.4747972, "1"],
[54.9151202833, 82.4748550667, "4"],
[54.9149427, 82.4758335, "11"],
[54.91488335, 82.4751902167, "5"],
[54.9149361833, 82.4753859667, "7"],
[54.9149649167, 82.475589, "9"],
[54.9153104333, 82.4754419667, "10"],
[54.9151775667, 82.4750489, "6"],
[54.91523395, 82.4752497167, "8"],
[54.8190687333, 82.3738382833, "23"],
[54.8189306833, 82.3733703333, "25"],
[54.8190215667, 82.37468215, "15"],
[54.8191251667, 82.3740887167, "21"],
[54.81873305, 82.3726976833, "27A-27C"],
[54.8806986667, 82.4693562667, "63"],
[54.8809032, 82.46938395, "61"],
[54.88419255, 82.4697289167, "25"],
[54.8840685833, 82.4692688833, "26A"],
[54.8849148667, 82.4692615167, "24"],
[54.8847644833, 82.4697682667, "23"],
[54.8813066833, 82.4696684167, "55A"],
[54.8841734833, 82.4692622667, "26"],
[54.8840862833, 82.46972585, "27"],
[54.883927, 82.46906515, "28A"],
[54.8838748833, 82.4692541667, "28"],
[54.8838499, 82.4696946333, "29"],
[54.88359805, 82.4692251167, "30"],
[54.8837043833, 82.4696835, "31"],
[54.8834259333, 82.4692035833, "32"],
[54.88355905, 82.4696786667, "33"],
[54.8832160667, 82.4691627833, "34"],
[54.8834721833, 82.4701433, "35"],
[54.8829353667, 82.4691514, "36"],
[54.8833598667, 82.4701280667, "37"],
[54.8821233833, 82.4690720167, "44"],
[54.8818720333, 82.4690515667, "46"],
[54.8816436667, 82.4690230167, "48"],
[54.8815636667, 82.4686263, "50"],
[54.8818555333, 82.4695200333, "51"],
[54.8812979333, 82.4689347, "52A"],
[54.8814706833, 82.46880395, "52"],
[54.8816095333, 82.46944925, "53"],
[54.8816625, 82.4696671833, "53A"],
[54.8811724833, 82.46894365, "54"],
[54.8833521, 82.46965845, "39"],
[54.882727, 82.4691108167, "40"],
[54.88320755, 82.4696409167, "41"],
[54.8830678333, 82.4696227833, "43"],
[54.8828830167, 82.4695893333, "45"],
[54.8827233167, 82.4695686167, "47"],
[54.88095035, 82.4689156, "56"],
[54.8811470667, 82.4694376833, "57"],
[54.8807286167, 82.4689006167, "58"],
[54.8809772667, 82.4695997, "59"],
[54.8855099667, 82.4700903333, "11A"],
[54.8863533667, 82.4694588667, "10"],
[54.8855251167, 82.46980435, "11"],
[54.8858918167, 82.4693764333, "12"],
[54.88541135, 82.46981195, "13"],
[54.8857694833, 82.4693831333, "14"],
[54.8853156333, 82.4697983, "15"],
[54.88556005, 82.4693647167, "16"],
[54.8851626, 82.4697849833, "17"],
[54.8853764833, 82.4693362333, "18"],
[54.8850294167, 82.4700537333, "19A"],
[54.8850045667, 82.4697427167, "19"],
[54.88522955, 82.4692991667, "20"],
[54.8869080667, 82.4699470333, "1"],
[54.8866734833, 82.4699262833, "3"],
[54.8868586667, 82.46949025, "4"],
[54.8866564167, 82.4694635, "6"],
[54.8864874833, 82.4690444333, "8A"],
[54.8864948, 82.4694661333, "8"],
[54.8857426, 82.4698434167, "9"],
[54.8813893667, 82.46946355, "55"],
[54.8757085833, 82.4720279333, "14"],
[54.8760134667, 82.4732799333, "4"],
[54.8762548333, 82.4722784667, "9"],
[54.87627795, 82.47290345, "5"],
[54.8759331333, 82.4720918833, "16"],
[54.8759628833, 82.47273515, "8"],
[54.8762970167, 82.4732576833, "3"],
[54.8762245833, 82.47260565, "7"],
[54.8760141333, 82.4735054833, "2"],
[54.87599385, 82.4730087667, "6"],
[54.8759230167, 82.4724739333, "10"],
[54.8762960167, 82.4734868833, "1"],
[54.8760504333, 82.4719608, "18"],
[54.8759146, 82.4722788167, "12"],
[54.8741210833, 82.4688841833, "4"],
[54.874194, 82.4684628667, "3"],
[54.8738320667, 82.467738, "7C"],
[54.8739506833, 82.4677262667, "7B"],
[54.8738354667, 82.4680554, "7D"],
[54.8739794167, 82.4680445667, "7A"],
[54.8738342833, 82.46848195, "9"],
[54.8740206, 82.4684673, "5"],
[54.8739604167, 82.4688864, "6"],
[54.8735957167, 82.4683405333, "11"],
[54.8734235667, 82.4681024, "13"],
[54.87339585, 82.4678321167, "15"],
[54.8733727667, 82.46763935, "17"],
[54.8728499833, 82.46814045, "18B"],
[54.8728848, 82.468283, "18A"],
[54.8730660667, 82.4686787667, "12B"],
[54.8734160167, 82.4687180167, "10"],
[54.87312285, 82.4687848, "12A"],
[54.8730669833, 82.4679829333, "20"],
[54.8731389833, 82.4682574833, "16"],
[54.8732649167, 82.4684832833, "14"],
[54.8732605833, 82.4675842167, "19"],
[54.8729366833, 82.4674852167, "24"],
[54.8730152333, 82.4677481333, "22"],
[54.87312065, 82.4675707, "21"],
[54.7940869167, 82.4650218, "53"],
[54.7987550833, 82.46275265, "10"],
[54.7930822167, 82.4661922833, "60"],
[54.9811612, 82.51623075, "170"],
[54.980836, 82.5157299167, "171"],
[54.9807136667, 82.5162809333, "172"],
[54.8615888667, 82.47847875, "25"],
[54.8612666833, 82.4791558, "31"],
[54.86047605, 82.48172545, "60"],
[54.8620611333, 82.4774431167, "13"],
[54.8607505167, 82.4799311167, "41"],
[54.8611511833, 82.4794658167, "35"],
[54.86108515, 82.4796282, "37"],
[54.8604406, 82.48091835, "55"],
[54.8595911333, 82.483664, "72"],
[54.8582950167, 82.4794636833, "1/55"],
[54.8599109167, 82.4805425167, "49"],
[54.86081285, 82.4790711333, "33"],
[54.9125544667, 82.4795344, "6A"],
[54.9129032667, 82.479114, "8"],
[54.9131012, 82.4790179333, "10"],
[54.9132466667, 82.4789829167, "11"],
[54.9130141, 82.4787519333, "1"],
[54.9128543833, 82.4788087167, "2"],
[54.9126783167, 82.47889955, "3"],
[54.9125031333, 82.47905685, "4"],
[54.91254025, 82.4792764833, "5"],
[54.9127399333, 82.4793322333, "7"],
[54.9130969667, 82.47952775, "9"],
[54.9126911167, 82.4796185, "6"],
[54.8188045667, 82.445279, "356B"],
[54.8182903167, 82.4447447333, "356A"],
[54.8086473833, 82.4195512167, "27"],
[54.8137567, 82.4426504333, "299"],
[54.8131862167, 82.4434878167, "297"],
[54.8157127333, 82.43953285, "300A"],
[54.8094742167, 82.4189907, "19"],
[54.80933355, 82.4191978667, "23"],
[54.8084224833, 82.4207951, "41"],
[54.8095742167, 82.43605105, "226"],
[54.81325255, 82.4410722, "291"],
[54.8149016667, 82.44148445, "310"],
[54.8155769667, 82.44213865, "316"],
[54.8161747167, 82.4426252167, "326A"],
[54.81712155, 82.4417707667, "326B"],
[54.8169698833, 82.4434206167, "332"],
[54.81770375, 82.4442239833, "346"],
[54.81930575, 82.4457899333, "370"],
[54.82310865, 82.4495740167, "422"],
[54.8103162667, 82.4344773833, "224B"],
[54.8100267333, 82.4348309167, "224A"],
[54.8072155167, 82.4256129167, "88B"],
[54.8070962167, 82.42278495, "59"],
[54.8044940333, 82.4270097, "105"],
[54.8046275667, 82.4276069, "110"],
[54.8047349, 82.43229485, "165"],
[54.8073398, 82.4232142167, "68"],
[54.8064126167, 82.4330381167, "188"],
[54.8063987833, 82.4339707667, "209"],
[54.8103206333, 82.4378506833, "241"],
[54.8117777667, 82.4393874, "269"],
[54.8074375833, 82.43233545, "192"],
[54.8099668167, 82.4365891667, "236"],
[54.8038524, 82.4307279167, "156"],
[54.808759, 82.4183171167, "17"],
[54.805885, 82.4246946333, "81"],
[54.8072272, 82.4225943333, "57"],
[54.8056120333, 82.4262290333, "98"],
[54.80400575, 82.4287991167, "122"],
[54.8162936333, 82.43817215, "300B"],
[54.80809795, 82.4212756, "49"],
[54.8102496667, 82.4184802, "8"],
[54.8057899167, 82.43198855, "174"],
[54.8060113, 82.4256459333, "88A"],
[54.8183982, 82.4416558, "336"],
[54.8108804, 82.4393530667, "257"],
[54.81106865, 82.4386178, "255"],
[54.816436, 82.4370654, "298"],
[54.8152743833, 82.4390058833, "298A"],
[54.8136452667, 82.44031535, "288"],
[54.8123581, 82.44091935, "285"],
[54.81283995, 82.4401099833, "283"],
[54.8198763333, 82.4462982, "382"],
[54.8164479167, 82.4439082, "331"],
[54.80775795, 82.4225746667, "62"],
[54.8039981833, 82.43163845, "161"],
[54.81343775, 82.4401047167, "286"],
[54.92047495, 82.46336425, "9"],
[54.9203008333, 82.4618285667, "10"],
[54.9198670667, 82.4617700333, "6"],
[54.9207259667, 82.4627925167, "18"],
[54.9204614, 82.4619784833, "12"],
[54.9205793667, 82.4621705667, "14"],
[54.9207471167, 82.463665, "22"],
[54.9208443, 82.4640230833, "24"],
[54.9207801667, 82.4632019667, "20"],
[54.919291, 82.4622796167, "1"],
[54.92066135, 82.4624384833, "16"],
[54.9203523333, 82.4637463, "11"],
[54.9192657167, 82.4618642833, "2"],
[54.9197237333, 82.4622129, "3"],
[54.91957955, 82.4618272333, "4"],
[54.9201776333, 82.4622242, "5"],
[54.9203935, 82.4628145667, "7"],
[54.9201192, 82.46174985, "8"],
[54.9031613333, 82.4779369333, "8"],
[54.90302285, 82.47799245, "9"],
[54.9033285333, 82.4778655833, "7"],
[54.90346695, 82.4777957167, "6B"],
[54.9031769667, 82.4783186167, "1"],
[54.9034699667, 82.47848295, "2A"],
[54.90334345, 82.4782583833, "2"],
[54.9035249833, 82.4781788667, "3"],
[54.9037982667, 82.4780497167, "4A"],
[54.9037089833, 82.4781017333, "4"],
[54.9035266667, 82.4777643667, "6A"],
[54.9036756833, 82.4778188333, "5"],
[54.9129985333, 82.4689246333, "3"],
[54.9132911, 82.4686436333, "4"],
[54.9127876667, 82.4680122167, "13"],
[54.9126336667, 82.46802445, "13A"],
[54.91304995, 82.4678746833, "10"],
[54.91280555, 82.4681958333, "11"],
[54.9127504833, 82.4677229167, "15"],
[54.9133710167, 82.4688942167, "2"],
[54.9129377, 82.4687422333, "5"],
[54.9128397333, 82.4683664833, "9"],
[54.9125584, 82.4677322333, "15A"],
[54.9132129833, 82.4683870333, "6"],
[54.9128774667, 82.4685356, "7"],
[54.9131322833, 82.4681105167, "8"],
[54.9164839667, 82.4695277167, "2/205"],
[54.9167949333, 82.4782119333, "287"],
[54.9086755, 82.4537326833, "37"],
[54.91527815, 82.4546945333, "2/88"],
[54.9142658167, 82.4551371, "1/88"],
[54.9145371, 82.4555229667, "88"],
[54.9167784167, 82.4698118167, "209"],
[54.91671315, 82.4695459, "207"],
[54.916654, 82.4692565, "203"],
[54.9168566667, 82.4764833167, "269"],
[54.9170098667, 82.4835371333, "332"],
[54.9109654167, 82.455206, "60"],
[54.9170810333, 82.4814135167, "310"],
[54.9168965667, 82.4758632667, "263"],
[54.9154102833, 82.46304445, "149"],
[54.9154961, 82.4634764667, "153"],
[54.9152487667, 82.4638892333, "157"],
[54.9156422333, 82.4641169833, "159"],
[54.9158050167, 82.4648025333, "165"],
[54.91375215, 82.4584178167, "106"],
[54.9147696833, 82.4594047833, "114"],
[54.91474835, 82.46019985, "121"],
[54.9158845167, 82.4586385833, "112"],
[54.9150857, 82.459884, "120"],
[54.9126885833, 82.4573289333, "82"],
[54.91648165, 82.4694261333, "1/205"],
[54.9168508333, 82.4701398833, "211"],
[54.9169940167, 82.4708593833, "219"],
[54.9170359, 82.4710790167, "221"],
[54.91708375, 82.4713339, "223"],
[54.9170401, 82.4721885167, "231"],
[54.9170336667, 82.4724657667, "233"],
[54.9169188667, 82.4749939667, "249"],
[54.9168660833, 82.4760673333, "265"],
[54.91686435, 82.4768689833, "271"],
[54.9166818667, 82.4769821, "273"],
[54.9168443333, 82.4772235167, "275"],
[54.9166369667, 82.4773580167, "277"],
[54.9165761667, 82.4777388, "279"],
[54.9168418833, 82.47757295, "281"],
[54.9168319167, 82.47791855, "283"],
[54.9165834833, 82.47804975, "285"],
[54.91697015, 82.4853758167, "344"],
[54.9180125667, 82.4811616, "316"],
[54.9169954833, 82.48221265, "318"],
[54.9157653333, 82.4543129833, "3/88"],
[54.9154571667, 82.4552445, "4/88"],
[54.8827312167, 82.4872892833, "5"],
[54.8831903667, 82.4877676167, "8"],
[54.8828024333, 82.4875113, "7"],
[54.8831045, 82.4875104167, "6"],
[54.8828241, 82.4877701, "9"],
[54.88302025, 82.4867592333, "2"],
[54.8827238667, 82.4870656, "3"],
[54.8832792333, 82.48802495, "10"],
[54.88271135, 82.4868632, "1"],
[54.8830189167, 82.4869722, "4"],
[54.8828316667, 82.4879782167, "11"],
[54.8831031667, 82.4879840167, "12"],
[54.8829747, 82.4879948833, "13"],
[54.88274605, 82.48484915, "21"],
[54.8834571667, 82.4855031833, "4"],
[54.8834955333, 82.4856944167, "2"],
[54.8838132333, 82.4854477333, "3"],
[54.8835369833, 82.4848281833, "11"],
[54.88336725, 82.48485965, "13"],
[54.8831959833, 82.48485645, "15"],
[54.8828621167, 82.48476675, "19"],
[54.8838400833, 82.4849657333, "7"],
[54.8837638167, 82.4848016167, "9"],
[54.8829594167, 82.4854216, "10"],
[54.8827830667, 82.4855451, "12"],
[54.88274165, 82.4853534, "14"],
[54.8827611667, 82.4850917, "16"],
[54.8830644, 82.48501895, "17"],
[54.8838288, 82.4856380833, "1"],
[54.8838275, 82.4852247167, "5"],
[54.883443, 82.4852514667, "6"],
[54.8831229667, 82.4853610833, "8"],
[54.8145997, 82.4058182333, "13"],
[54.8147182333, 82.4078123, "28"],
[54.81457405, 82.4067919, "23"],
[54.8140701667, 82.4071422833, "27"],
[54.8142806667, 82.4076163167, "29"],
[54.8149311167, 82.4068842833, "22"],
[54.8150038333, 82.4059631, "16"],
[54.7951609167, 82.3942458333, "200"],
[54.7911471333, 82.3929187167, "159B"],
[54.7905987667, 82.3938164667, "159C"],
[54.7912155833, 82.3932714167, "159A"],
[54.79397065, 82.3941075167, "190"],
[54.7944302667, 82.3943967333, "196"],
[54.7902842667, 82.3925200667, "151"],
[54.79289115, 82.3931896, "174"],
[54.7936966833, 82.3937764, "188"],
[54.7941318167, 82.3948274667, "191"],
[54.7978721333, 82.3984214333, "249"],
[54.7981105667, 82.39574825, "232A"],
[54.7938025333, 82.3924897, "178"],
[54.7985639333, 82.3952936333, "232B"],
[54.7918765, 82.3926438167, "162"],
[54.7908330333, 82.39227155, "154"],
[54.7962404, 82.3968673, "225"],
[54.7923051, 82.3933906333, "171A"],
[54.7927951833, 82.3942652333, "171B"],
[54.7901405833, 82.3919332833, "146"],
[54.7965292833, 82.396445, "226"],
[54.7989539333, 82.3987508667, "258"],
[54.7975085, 82.3942399167, "218A"],
[54.7982403667, 82.3938506167, "218B"],
[54.7947115833, 82.3953049, "203"],
[54.7925679167, 82.3935303833, "171C"],
[54.7951510667, 82.3951699667, "206"],
[54.7942058167, 82.39426, "192"],
[54.8151522, 82.3671718, "2"],
[54.8124476333, 82.3641774667, "38C"],
[54.8142324833, 82.3640258333, "36"],
[54.8147477833, 82.3658554333, "18"],
[54.8149241, 82.3663270333, "14"],
[54.8127630333, 82.3645959667, "38D"],
[54.8802473333, 82.4761364833, "161"],
[54.8803540333, 82.4775673167, "169A"],
[54.8808955167, 82.4678431, "87A"],
[54.8812967167, 82.45925645, "22A"],
[54.8801625833, 82.4788012833, "181"],
[54.8801798667, 82.4784953, "179"],
[54.8805060333, 82.4783115333, "82"],
[54.8802037167, 82.4779421333, "171"],
[54.8802002, 82.4782253667, "173"],
[54.88066575, 82.4696257, "105"],
[54.88142225, 82.4685359, "99D"],
[54.880149, 82.4790061333, "183"],
[54.8807033, 82.4684905333, "99A"],
[54.8811922, 82.4685214167, "99C"],
[54.8809802667, 82.4685055, "99B"],
[54.88134225, 82.4657706, "69"],
[54.8807472167, 82.46754285, "83"],
[54.8802148333, 82.4776531667, "169"],
[54.8802820833, 82.4763336, "163"],
[54.8802558333, 82.4772608667, "165"],
[54.8806246667, 82.4705465167, "113"],
[54.88113685, 82.4643511667, "53A"],
[54.88095905, 82.4643489, "53"],
[54.88154715, 82.4657577833, "67"],
[54.8809616167, 82.4639502667, "49"],
[54.8802025833, 82.48084275, "191A"],
[54.8806056333, 82.47098625, "117"],
[54.88044865, 82.47329545, "127"],
[54.8804726333, 82.47306075, "125"],
[54.8806984167, 82.4686680667, "101"],
[54.8805955167, 82.4711419833, "117A"],
[54.8806145167, 82.4707781333, "115"],
[54.88164575, 82.45804455, "16B"],
[54.88036875, 82.4755842, "153"],
[54.8806508333, 82.4700866667, "109"],
[54.8815960333, 82.4577537, "14"],
[54.88151485, 82.4579781667, "16A"],
[54.8813847833, 82.4644447333, "55"],
[54.8813670167, 82.4645692667, "57"],
[54.8809571333, 82.4641156833, "51"],
[54.8816293, 82.45738225, "10"],
[54.8818759333, 82.4575147, "12A"],
[54.8820464833, 82.4575854833, "12B"],
[54.8820319167, 82.4576747167, "12C"],
[54.8818586167, 82.4576652167, "12D"],
[54.8810945667, 82.46145875, "36"],
[54.8810898, 82.46167115, "38"],
[54.8810809667, 82.461937, "40"],
[54.8810701667, 82.4621895167, "42"],
[54.8812240833, 82.45898385, "20"],
[54.88121955, 82.45918975, "22"],
[54.8811737667, 82.45983295, "24"],
[54.88115855, 82.46004515, "26"],
[54.8811441, 82.46023075, "28"],
[54.8814057333, 82.4604056667, "30"],
[54.8811296167, 82.4604632667, "32"],
[54.88144325, 82.4580904667, "18"],
[54.88168545, 82.4564695667, "2"],
[54.8809346833, 82.4645998167, "59"],
[54.8809249833, 82.4648314, "61"],
[54.8810648667, 82.4624290833, "44"],
[54.8816609833, 82.4570327667, "8"],
[54.8804975333, 82.4721639167, "119"],
[54.8804971667, 82.4724005167, "121"],
[54.8806352, 82.4729319167, "123A"],
[54.8804951667, 82.4726299167, "123"],
[54.8806614, 82.4698499833, "107"],
[54.8806724167, 82.4731077667, "125A"],
[54.8808698667, 82.47335925, "129"],
[54.8808554167, 82.4735094333, "131"],
[54.8804224667, 82.4735332333, "133"],
[54.8804913, 82.47469655, "137B"],
[54.8803901, 82.4747040167, "137"],
[54.8803887333, 82.47486625, "139"],
[54.8807482167, 82.46714865, "77A"],
[54.8807597833, 82.4669996167, "77"],
[54.8807607667, 82.4673298667, "79"],
[54.88104675, 82.46741105, "81"],
[54.8812452833, 82.4676640333, "85"],
[54.8809039167, 82.4650308333, "63"],
[54.88112735, 82.4652241167, "65A"],
[54.8808660833, 82.4654164833, "65"],
[54.8811361, 82.4657563, "71"],
[54.8808503, 82.4658921167, "73"],
[54.8808297667, 82.4661495833, "75"],
[54.8807330167, 82.4677691667, "87"],
[54.8811556833, 82.46787915, "89"],
[54.88071555, 82.4680383167, "91A"],
[54.8807704167, 82.46804005, "91B"],
[54.88083325, 82.4680391667, "91C"],
[54.8809986, 82.4680511, "91"],
[54.8807155167, 82.46826605, "93"],
[54.8809702167, 82.4682232667, "95"],
[54.8807815333, 82.4750173333, "143"],
[54.8803783667, 82.4751021, "145"],
[54.88035755, 82.4753576667, "147"],
[54.8807471667, 82.47541785, "149"],
[54.8807513667, 82.4755767167, "151"],
[54.8803393, 82.4758476333, "159"],
[54.8802462333, 82.4774083333, "167"],
[54.8800620667, 82.4804408, "189"],
[54.8800557667, 82.48072595, "191"],
[54.88004135, 82.481018, "193"],
[54.8807389667, 82.47578795, "155"],
[54.88007905, 82.4799234833, "185"],
[54.88086485, 82.4703347667, "111A"],
[54.8806350333, 82.4703154167, "111"],
[54.8800789, 82.4801471833, "187"],
[54.8800045833, 82.4815507667, "197"],
[54.8800214333, 82.4812237167, "195"],
[54.8939151167, 82.4701667, "27"],
[54.8936762, 82.4701298, "31"],
[54.8924783167, 82.4700222667, "47"],
[54.8918865167, 82.469973, "51"],
[54.89367495, 82.4697996667, "24"],
[54.8943151667, 82.4702028667, "7"],
[54.8941286667, 82.4702044, "23"],
[54.8942378667, 82.4698431, "2"],
[54.8945567833, 82.47024855, "1/1-3/1"],
[54.8935522667, 82.4697719, "28"],
[54.8939433, 82.4703330667, "25"],
[54.8937860667, 82.4701428667, "29"],
[54.8935538167, 82.4701164833, "41"],
[54.8941460167, 82.46983875, "14"],
[54.8938438167, 82.46980825, "18"],
[54.8937419667, 82.4698073167, "22"],
[54.8944316, 82.4702330333, "3"],
[54.8943035167, 82.4704350167, "9"],
[54.8926233833, 82.4700377333, "43"],
[54.8922256167, 82.47000115, "49"],
[54.8917971667, 82.46961, "54"],
[54.8926854, 82.469645, "40"],
[54.8921227167, 82.4696225333, "48"],
[54.8939403167, 82.4698126, "16"],
[54.8909714667, 82.4681493667, "33"],
[54.89113605, 82.4681601333, "31"],
[54.8912736333, 82.4686223167, "26"],
[54.892202, 82.4686328333, "16"],
[54.8921055833, 82.46861625, "18"],
[54.8912406833, 82.4681574833, "27"],
[54.89073535, 82.4685119833, "32"],
[54.89037515, 82.4686127333, "36"],
[54.8907882833, 82.4681261167, "37-39"],
[54.8905470833, 82.46806415, "41"],
[54.8928384833, 82.4687398333, "4"],
[54.8927622667, 82.46885875, "8"],
[54.8926823333, 82.4687259, "10"],
[54.89258095, 82.4687121167, "12"],
[54.89248485, 82.4687019167, "14"],
[54.9064365333, 82.4541838333, "29"],
[54.9065554833, 82.4549096667, "1/35"],
[54.9060750333, 82.4550532833, "3/35"],
[54.9058351667, 82.4555274667, "5/35"],
[54.9055143333, 82.4559182333, "7/35"],
[54.9065810667, 82.4558807167, "36"],
[54.9065682333, 82.4553069, "37"],
[54.9064074667, 82.4522252167, "9"],
[54.9059521, 82.45592445, "2/35"],
[54.9108997167, 82.4805822667, "3"],
[54.9109122833, 82.47947205, "6A"],
[54.9109177167, 82.47936065, "8"],
[54.911182, 82.4797094, "10"],
[54.9113005167, 82.4794321333, "12"],
[54.9111916333, 82.4793347333, "12A"],
[54.9112471833, 82.4797754667, "14"],
[54.9112473667, 82.4800788167, "11"],
[54.9113031333, 82.479914, "13"],
[54.91063835, 82.4803100333, "1"],
[54.9104951, 82.4800418667, "2"],
[54.9107454333, 82.4798887833, "4"],
[54.9108743667, 82.4802328833, "5"],
[54.9109565333, 82.4797847, "6"],
[54.9110407167, 82.4801576333, "7"],
[54.9112238167, 82.4804073167, "9"],
[54.921572, 82.4690554667, "8"],
[54.9210102667, 82.4691739667, "1"],
[54.9209054, 82.4687952333, "2"],
[54.92139265, 82.4695081333, "3"],
[54.9212156833, 82.4688233667, "4"],
[54.92161785, 82.4693603333, "5"],
[54.9215667, 82.4686771667, "6"],
[54.8971280667, 82.3833620167, "104"],
[54.8928069667, 82.3849023833, "58"],
[54.8960316833, 82.3834830167, "1/84"],
[54.8904228167, 82.38549425, "28"],
[54.8953458333, 82.3837370167, "84"],
[54.82145425, 82.3649986833, "7"],
[54.81972895, 82.3640394833, "24"],
[54.8211835333, 82.3645971667, "11"],
[54.8207776167, 82.3647366833, "14"],
[54.8209467167, 82.3640718167, "15"],
[54.8203904333, 82.3652387, "12"],
[54.9137399667, 82.3922778167, "2/73"],
[54.91124595, 82.39246205, "46"],
[54.9139008833, 82.3922517333, "3/73"],
[54.91350815, 82.39233345, "1/73"],
[54.9176178167, 82.4598785667, "19"],
[54.9184013833, 82.4603797833, "14"],
[54.9186543333, 82.4622474833, "6"],
[54.9173606667, 82.46006885, "19B"],
[54.9174988, 82.4603532, "19C"],
[54.9177378167, 82.4601680667, "19D"],
[54.91904695, 82.4627864167, "1"],
[54.9187282, 82.46300145, "2"],
[54.91901275, 82.46243355, "3"],
[54.9186912, 82.46265345, "4"],
[54.91856195, 82.4613744167, "10"],
[54.91851535, 82.4609194, "12"],
[54.9189516833, 82.4617426667, "5"],
[54.9188849, 82.4613117333, "7"],
[54.9186173667, 82.4618227833, "8"],
[54.9188575667, 82.4608533167, "9"],
[54.9173323833, 82.4597201333, "19A"],
[54.9178891, 82.4598711167, "17"],
[54.9180202833, 82.46025785, "16"],
[54.9016754833, 82.4689591, "10"],
[54.9008128667, 82.4686879833, "2"],
[54.9009759333, 82.46843985, "1"],
[54.9014464, 82.4685093167, "5"],
[54.90130095, 82.4688850167, "6"],
[54.9016211667, 82.4685312667, "7"],
[54.9014644167, 82.4690226833, "8"],
[54.9014864167, 82.4687479667, "9"],
[54.9010720333, 82.4687982333, "4"],
[54.9011746, 82.4685293333, "3"],
[54.9013743333, 82.4862629167, "3"],
[54.9017248, 82.48698725, "6"],
[54.9012848, 82.4859531833, "2"],
[54.9016014833, 82.4860586167, "10"],
[54.9014527667, 82.4865486167, "4"],
[54.90159855, 82.48677855, "5"],
[54.90183005, 82.4869517667, "7"],
[54.9017713833, 82.4866214167, "8"],
[54.9016935, 82.4863532333, "9"],
[54.90753, 82.46902475, "11"],
[54.9095893167, 82.4677886667, "39B"],
[54.9109792833, 82.4682655, "46A"],
[54.91108275, 82.4685749667, "46B"],
[54.91115625, 82.4686338833, "48C"],
[54.9110050167, 82.46807085, "48A"],
[54.91095895, 82.46781955, "48"],
[54.9108204, 82.4678798667, "46"],
[54.9110788833, 82.4683501, "48B"],
[54.9113655167, 82.4678862333, "52B"],
[54.9108344833, 82.4674433667, "45"],
[54.9080208833, 82.4692374833, "22"],
[54.9083263167, 82.4686353333, "27"],
[54.90844025, 82.4697672333, "26"],
[54.90818025, 82.4691643, "22A"],
[54.91258895, 82.4673144833, "64"],
[54.9123684167, 82.4671105167, "62"],
[54.9127896, 82.4663434833, "67"],
[54.91150695, 82.46757075, "54"],
[54.9098419667, 82.4683599167, "40"],
[54.91097155, 82.4673723, "47"],
[54.9078617667, 82.4693023667, "20"],
[54.9089053833, 82.4683338, "29"],
[54.9099875333, 82.46828695, "42"],
[54.9113045167, 82.4682282833, "50A"],
[54.9107373, 82.4665437833, "47C"],
[54.9108713, 82.4665006167, "49B"],
[54.9129575833, 82.4665350833, "69"],
[54.9108057333, 82.4667861, "47B"],
[54.9108904167, 82.4670609667, "47A"],
[54.9110041, 82.4668838667, "49A"],
[54.9111488833, 82.4673072667, "49"],
[54.9127369333, 82.46653495, "65"],
[54.91122205, 82.46770665, "52"],
[54.9113599, 82.467657, "52A"],
[54.9075002667, 82.4694598, "12"],
[54.9076741, 82.46939185, "14"],
[54.9078864833, 82.4699014333, "16"],
[54.9079676667, 82.46986515, "18"],
[54.90833225, 82.4695654167, "24"],
[54.9084313667, 82.4690023, "28"],
[54.9096631167, 82.46843925, "38"],
[54.9096189, 82.4680248667, "39"],
[54.911315, 82.4684015667, "50"],
[54.9073078333, 82.4691221167, "9"],
[54.9093386167, 82.4686052333, "34"],
[54.9091743667, 82.4682295833, "35"],
[54.90945425, 82.4681136333, "37"],
[54.90950645, 82.4685246333, "36"],
[54.9091745333, 82.4686900667, "32"],
[54.9127273333, 82.4669306667, "66"],
[54.913043, 82.4669127667, "68"],
[54.9113586333, 82.4672288167, "51"],
[54.9113531667, 82.4670099667, "51A"],
[54.9127951, 82.46667535, "71"],
[54.884095, 82.4568770667, "69A"],
[54.8838324333, 82.4568632333, "73A"],
[54.8866347667, 82.4565719833, "43"],
[54.8906992, 82.4569129667, "5"],
[54.8905596667, 82.4568912833, "7"],
[54.8892758333, 82.456777, "13A"],
[54.8901881167, 82.45687625, "1/11-11/11"],
[54.89070845, 82.4565194333, "1/4-3/4"],
[54.8902009333, 82.4563996667, "1/6-32/6"],
[54.8880562333, 82.4552566667, "26A"],
[54.8844905833, 82.4563941, "65"],
[54.8840861833, 82.45635875, "69"],
[54.8863777, 82.45685, "45A"],
[54.8909978167, 82.4569555833, "3"],
[54.8863633167, 82.4571221667, "45B"],
[54.8864835667, 82.4565624833, "45"],
[54.8881257667, 82.4569633333, "25A"],
[54.8905126667, 82.4574578833, "5A"],
[54.8907166167, 82.4575558333, "5B"],
[54.8866317167, 82.4572218, "41A"],
[54.8873822167, 82.4566324, "33"],
[54.8872964167, 82.4566407167, "35"],
[54.8866143833, 82.4569883667, "41"],
[54.8837334333, 82.45685885, "75A"],
[54.8860936, 82.4570698167, "49"],
[54.8855037167, 82.4564867333, "57"],
[54.8847617833, 82.4564164833, "59"],
[54.8844513167, 82.4566735333, "65A"],
[54.88419435, 82.45689485, "67A"],
[54.8842829333, 82.4563860333, "67"],
[54.88391675, 82.4563527, "73"],
[54.8837116667, 82.4563469333, "75"],
[54.889394, 82.4567865833, "13"],
[54.8890782333, 82.4567699333, "15"],
[54.8888433833, 82.4567615833, "17"],
[54.8886293333, 82.45674825, "19"],
[54.8884455333, 82.4567414833, "21"],
[54.8882809333, 82.45673085, "23"],
[54.8881163667, 82.456655, "25"],
[54.8880094667, 82.4562455667, "26"],
[54.89142225, 82.4569765, "1"],
[54.8914418, 82.4565121, "2"],
[54.8870694, 82.4566186333, "37"],
[54.8868689667, 82.45709495, "39A"],
[54.8868342167, 82.4565953333, "39"],
[54.8863517167, 82.4573732167, "45C"],
[54.8861983667, 82.4570712667, "47A"],
[54.8862286, 82.4568411833, "47B"],
[54.8880125833, 82.4547576833, "26B"],
[54.8860945833, 82.4565352167, "49A"],
[54.8904199167, 82.4568860167, "1/9-12/9"],
[54.8857833, 82.4565171833, "53"],
[54.8856455167, 82.45651885, "55"],
[54.8817373833, 82.4556858833, "72"],
[54.88593655, 82.45653005, "51"],
[54.8862765833, 82.4565127, "47"],
[54.8775379833, 82.4825127167, "28A"],
[54.87727315, 82.482376, "28"],
[54.87729155, 82.4821068667, "26"],
[54.8769019667, 82.4786293, "4C"],
[54.8767004333, 82.4787606, "4B"],
[54.8772910833, 82.4818029333, "24"],
[54.8771890667, 82.48153255, "22"],
[54.87708045, 82.4812278, "20"],
[54.8775351, 82.4826397667, "30A"],
[54.8772534167, 82.4827040167, "30"],
[54.877579, 82.4818970667, "24A"],
[54.876712, 82.4812017667, "21"],
[54.8773884333, 82.4832404167, "36"],
[54.8769804167, 82.4824093, "27"],
[54.8766636667, 82.482704, "31B"],
[54.8769937167, 82.4830107167, "31"],
[54.8767516667, 82.479482, "8A"],
[54.8769705667, 82.4818533667, "23"],
[54.8766017167, 82.48246365, "29A"],
[54.8764641833, 82.4825834, "29B"],
[54.8769964667, 82.4820980833, "25"],
[54.8769606333, 82.4826863833, "29"],
[54.87679475, 82.4828674667, "31A"],
[54.8770826, 82.4832520333, "33"],
[54.8772377, 82.48334835, "35"],
[54.8775367167, 82.48363695, "36A"],
[54.8775890833, 82.4831116, "34"],
[54.8773408667, 82.4829609, "32"],
[54.8762828667, 82.4801149667, "11"],
[54.87597055, 82.4792251167, "3"],
[54.8760466167, 82.4794375833, "5"],
[54.8761314, 82.4796617, "7"],
[54.8764699833, 82.48058085, "15"],
[54.8765455167, 82.4808159833, "17"],
[54.8767292667, 82.48028335, "14"],
[54.8765539833, 82.4798159833, "10"],
[54.87646245, 82.4795675, "8"],
[54.8763712167, 82.4793057167, "6"],
[54.8776228167, 82.481266, "20B"],
[54.8775729667, 82.482055, "26A"],
[54.8776195833, 82.4814085333, "22B"],
[54.8765414, 82.4790666667, "6A"],
[54.8773585333, 82.48356815, "38A"],
[54.8762120667, 82.4798686667, "9"],
[54.8766452667, 82.4800751167, "12"],
[54.8763675, 82.48034475, "13"],
[54.8766347833, 82.4810402667, "19"],
[54.8774052167, 82.4812147167, "20A"],
[54.8774057667, 82.4814070167, "22A"],
[54.8762723167, 82.479009, "4"],
[54.8761971167, 82.4787850833, "2"],
[54.8767849, 82.4796004667, "10A"],
[54.87648555, 82.47892075, "4A"],
[54.8767848, 82.4788595833, "6B"],
[54.8997092333, 82.4818082, "7"],
[54.8999472667, 82.4825543, "15"],
[54.8999358167, 82.4815958167, "4"],
[54.9000434833, 82.4825363833, "17"],
[54.9002215333, 82.4828014167, "16"],
[54.90002095, 82.4818578, "6"],
[54.9000853167, 82.48210025, "8"],
[54.8997820833, 82.4820087333, "9"],
[54.8998240167, 82.4822147833, "11"],
[54.8998576333, 82.48247455, "13"],
[54.8996422833, 82.4815878833, "5"],
[54.9002942833, 82.482764, "14"],
[54.9001676167, 82.4824792667, "12"],
[54.89953345, 82.4811912333, "1"],
[54.8997866833, 82.4810307833, "2"],
[54.8995802333, 82.4813792333, "3"],
[54.9001401333, 82.4822942333, "10"],
[54.8914648833, 82.4772108167, "7"],
[54.8919011833, 82.47723515, "1"],
[54.89187105, 82.4768182, "2"],
[54.8913584, 82.4765354167, "3/6"],
[54.8897734833, 82.47664395, "22"],
[54.8913508, 82.47668445, "1/6"],
[54.8915273667, 82.4762602, "12/6"],
[54.8916285, 82.4772315333, "5"],
[54.8913796, 82.4761122167, "7/6"],
[54.8915023833, 82.4767099333, "8/6"],
[54.89152, 82.4763519333, "11/6"],
[54.8915372, 82.4760592333, "14/6"],
[54.89153065, 82.4761616667, "13/6"],
[54.8915142333, 82.4764663667, "10/6"],
[54.8913717333, 82.4763199333, "5/6"],
[54.8905254833, 82.4766904, "14"],
[54.8903609333, 82.4766834833, "16"],
[54.88999105, 82.4766566833, "20"],
[54.8898741167, 82.4770700667, "21"],
[54.88946535, 82.4766037667, "24"],
[54.8890790333, 82.4764705833, "28"],
[54.88883405, 82.4767525667, "29"],
[54.8886383, 82.47663365, "31"],
[54.8913739667, 82.47622135, "6/6"],
[54.8913652833, 82.47641835, "4/6"],
[54.8901779667, 82.4766671167, "18"],
[54.8843281, 82.4794198167, "104"],
[54.88535045, 82.4866782167, "184"],
[54.8854485333, 82.4864475167, "182"],
[54.8867971833, 82.4705084167, "34"],
[54.8873998833, 82.4682775833, "20"],
[54.8873415667, 82.46844545, "22"],
[54.884267, 82.4871188333, "189"],
[54.8843410333, 82.4813043, "114A"],
[54.8836708667, 82.47833265, "90A"],
[54.88402285, 82.4784176667, "2/92"],
[54.8841246, 82.4784325, "1/92"],
[54.8874953667, 82.4680249333, "18"],
[54.8882076333, 82.4665346667, "2"],
[54.8847749, 82.4777212667, "89"],
[54.8847129167, 82.4883360167, "198"],
[54.8852412667, 82.4950174167, "258"],
[54.8851558333, 82.4809135167, "111A"],
[54.88425915, 82.490565, "219"],
[54.8843227167, 82.4792336667, "102"],
[54.8853703333, 82.47613215, "70"],
[54.8841992667, 82.4963818333, "267"],
[54.8839456333, 82.47862415, "96"],
[54.8849404833, 82.4785609167, "91B"],
[54.8834439167, 82.5003043667, "309"],
[54.8859648333, 82.4880242333, "2/194"],
[54.88679165, 82.4708238833, "36"],
[54.8846928333, 82.4966356667, "270"],
[54.8843265, 82.4790500333, "100"],
[54.8847626167, 82.48078795, "109"],
[54.88474565, 82.4788347167, "93"],
[54.8843263, 82.4786463833, "94"],
[54.8847555167, 82.4792519167, "95"],
[54.8847507833, 82.4802669333, "103"],
[54.8877261667, 82.4675846667, "1/14-8/14"],
[54.884759, 82.4805435333, "105"],
[54.8843192, 82.4802557667, "108"],
[54.8847632167, 82.4813335333, "113"],
[54.8880664667, 82.4668566667, "4"],
[54.8843192833, 82.4781745833, "88"],
[54.8842179667, 82.4927192667, "239"],
[54.8842136333, 82.4948947333, "257"],
[54.8841869, 82.4971351, "275"],
[54.8842592167, 82.487337, "191"],
[54.8842746, 82.4896256667, "213"],
[54.8842726, 82.4898100833, "1/213"],
[54.8846939167, 82.49589215, "264"],
[54.8847557667, 82.480013, "101"],
[54.8847654333, 82.488289833, "117"],
[54.8843088167, 82.4819155, "120"],
[54.88495845, 82.4760208167, "74A"],
[54.8858546833, 82.48954395, "1/214"],
[54.8847226333, 82.49078585, "222"],
[54.8853824333, 82.4904875333, "220"],
[54.8851609, 82.4769312833, "75"],
[54.8832135333, 82.4966401667, "273"],
[54.8871125333, 82.4687638667, "24A"],
[54.8836533833, 82.49965535, "303"],
[54.8847623833, 82.4784197, "91"],
[54.8853003167, 82.4812587, "113B"],
[54.8839543333, 82.4780861333, "86"],
[54.8846811667, 82.49516135, "260"],
[54.8856284667, 82.4877555167, "1/194"],
[54.88470535, 82.4899576833, "1/218"],
[54.8858448, 82.4898961, "2/218"],
[54.8857487667, 82.4882389667, "3/194"],
[54.8858920833, 82.4886561833, "4/194"],
[54.8854131167, 82.4885925, "202"],
[54.8852231333, 82.48536035, "174"],
[54.88721395, 82.4674219167, "12A"],
[54.8850944, 82.4812663333, "113A"],
[54.8858759667, 82.4852820333, "172"],
[54.8843297167, 82.4777121167, "80"],
[54.8867259833, 82.4716590667, "42"],
[54.8841291333, 82.4812217833, "114"],
[54.8878423667, 82.46733415, "10"],
[54.8873731, 82.46722755, "12"],
[54.8873645167, 82.4677444, "16A"],
[54.8873792, 82.4676194833, "16B"],
[54.8871674667, 82.4675664, "16C"],
[54.8871631333, 82.4677062, "16D"],
[54.88761885, 82.4678307833, "16"],
[54.8872513, 82.4677940833, "18A"],
[54.8868627833, 82.4703096167, "32"],
[54.8866729333, 82.4725751667, "46"],
[54.8866649333, 82.4727545667, "48"],
[54.8866508833, 82.4729862833, "50"],
[54.8866308167, 82.4733044333, "52"],
[54.8866201167, 82.4735912, "54"],
[54.8866046, 82.4738994833, "56"],
[54.8867646333, 82.4710940833, "38"],
[54.8867434167, 82.4713738, "40"],
[54.8865795333, 82.471651, "42A"],
[54.8867192167, 82.4718726833, "44"],
[54.8879124167, 82.4671744, "8"],
[54.8847677333, 82.48104275, "111"],
[54.8842908, 82.4810946667, "112"],
[54.8847655167, 82.48152025, "115"],
[54.8842992333, 82.4815339, "116"],
[54.8843125167, 82.488239167, "118"],
[54.8847685333, 82.4795402167, "97"],
[54.8847615667, 82.4797710333, "99"],
[54.8849925167, 82.48009295, "101A"],
[54.8850730167, 82.4803513167, "103A"],
[54.8850517667, 82.4806989167, "107"],
[54.8842659667, 82.4776982667, "80A"],
[54.8843255167, 82.4779083833, "82"],
[54.88372445, 82.4779537667, "84A"],
[54.88391925, 82.4779436333, "84"],
[54.8839372667, 82.4783140167, "90"],
[54.8849343833, 82.47834135, "91A"],
[54.8843215, 82.47842775, "92"],
[54.88379995, 82.4786243333, "96A"],
[54.8843308167, 82.47886585, "98"],
[54.8846524333, 82.4766493167, "76"],
[54.8845290833, 82.4764747667, "78A"],
[54.8845141833, 82.47672525, "78"],
[54.8847249, 82.4874558833, "192"],
[54.88422795, 82.4880656333, "197"],
[54.8842586167, 82.4888764, "205"],
[54.8847152, 82.4891847, "206"],
[54.8847452333, 82.48597775, "180"],
[54.8842725667, 82.4862342167, "181"],
[54.8842734167, 82.4864492, "183"],
[54.88427415, 82.4866713, "185"],
[54.8847306167, 82.48657095, "186"],
[54.88426915, 82.48689685, "187"],
[54.8842773667, 82.4856398, "179"],
[54.8852212833, 82.4924678, "236"],
[54.8854883167, 82.4880036333, "194"],
[54.8854214333, 82.48956085, "212"],
[54.8853153667, 82.4872245, "190"],
[54.8841928667, 82.4931503833, "241"],
[54.8844711667, 82.4984144, "290"],
[54.8842522667, 82.4992926333, "296"],
[54.88368415, 82.4993789667, "299"],
[54.8852287833, 82.49615515, "268"],
[54.8859148667, 82.4897217, "214"],
[54.8872887667, 82.4686820167, "24"],
[54.8862459167, 82.47553185, "66"],
[54.884721, 82.48537045, "176"],
[54.88427605, 82.4851847833, "82"],
[54.8842737833, 82.4854139833, "177"],
[54.88469795, 82.4945610167, "252"],
[54.8853844667, 82.47677695, "73"],
[54.8850111333, 82.4763984, "74"],
[54.8847382167, 82.4869962333, "188"],
[54.8872426333, 82.4689359833, "26"],
[54.8847101833, 82.4880854667, "196"],
[54.8850733, 82.4902483167, "218"],
[54.8865769333, 82.4741854167, "58"],
[54.8865507, 82.4747159333, "62"],
[54.88798625, 82.46700445, "6"],
[54.8865659, 82.4744709833, "60"],
[54.8865476667, 82.4748834667, "64"],
[54.8871864333, 82.4691891, "28"],
[54.8871582, 82.4693788167, "30"],
[54.8869467833, 82.4687736667, "26A"],
[54.8856446167, 82.4771148167, "71"],
[54.8851925333, 82.4762547833, "72"],
[54.8869292167, 82.4689437, "26B"],
[54.88426605, 82.48474735, "171"],
[54.884281, 82.4849628667, "173"],
[54.8847245167, 82.4848834667, "170"],
[54.8680607667, 82.4844529, "318"],
[54.86322315, 82.477174, "229"],
[54.86023885, 82.47171045, "177"],
[54.86190065, 82.4739293333, "200"],
[54.8673314333, 82.4835841, "306"],
[54.8671325167, 82.4839981167, "307"],
[54.8657566333, 82.4825140333, "287"],
[54.85661605, 82.4580103167, "35"],
[54.8584986667, 82.4693192667, "151"],
[54.86640715, 82.4833253333, "293"],
[54.8662972, 82.48401185, "301"],
[54.8615068, 82.4740312667, "197"],
[54.86248105, 82.4746844667, "208"],
[54.8654257333, 82.4789157833, "256"],
[54.86815405, 82.4856843833, "327"],
[54.8559617833, 82.4538523, "5"],
[54.8560217167, 82.4541485167, "7"],
[54.8545882, 82.4628883167, "73"],
[54.8623530667, 82.4756642667, "211"],
[54.8571193833, 82.46393905, "91"],
[54.8612014833, 82.47249975, "184"],
[54.8409288167, 82.37611985, "48"],
[54.8396866, 82.3762834833, "52"],
[54.840238, 82.3744657333, "75"],
[54.84304635, 82.3783802167, "24"],
[54.8407690333, 82.3753619333, "59"],
[54.8447812333, 82.3774333333, "5"],
[54.83956405, 82.3732069667, "82"],
[54.84004855, 82.3731001333, "83"],
[54.8401183167, 82.3739726667, "77B"],
[54.8406453, 82.3751587333, "63"],
[54.8435605667, 82.3793269333, "20"],
[54.848291667, 82.3760676667, "49"],
[54.8413693, 82.3763867167, "46"],
[54.8399756833, 82.3748775, "74"],
[54.8421274167, 82.3758927833, "47"],
[54.8433708, 82.37858675, "22"],
[54.8410302333, 82.3737431833, "77A"],
[54.7912387167, 82.4809981333, "33"],
[54.7921037167, 82.48244855, "34"],
[54.7931116833, 82.4894669167, "108"],
[54.7922422833, 82.4888664333, "109"],
[54.8904655, 82.4340570833, "16"],
[54.8912684167, 82.4347386333, "38"],
[54.8918202833, 82.4356853333, "41"],
[54.9076504833, 82.4808292167, "2"],
[54.9077122167, 82.4810869667, "3"],
[54.9078427, 82.4811889667, "4"],
[54.9079905333, 82.4810739167, "5"],
[54.9079955, 82.4808534333, "6"],
[54.9078875833, 82.48062165, "7"],
[54.8624973167, 82.3995043333, "1302"],
[54.86458815, 82.3984334333, "1302B"],
[54.8495279667, 82.3855142, "1105"],
[54.8409388, 82.3715485333, "965"],
[54.8497607833, 82.3787181667, "1048D"],
[54.8474886167, 82.3815213, "1071"],
[54.8692470333, 82.4060449833, "1399"],
[54.86903025, 82.4050720333, "1410"],
[54.8720073, 82.4080915167, "1435"],
[54.8472647, 82.3801392333, "1050"],
[54.8484202, 82.37745075, "1048B"],
[54.8501358167, 82.37656745, "1048C"],
[54.8464420667, 82.3786923167, "1048A"],
[54.8636343667, 82.3989099167, "1302A"],
[54.86024445, 82.39640055, "1262B"],
[54.8455550167, 82.3768668, "1032"],
[54.8498453667, 82.3860935167, "1113"],
[54.8508258833, 82.3877938167, "1129"],
[54.8538246333, 82.3925789833, "1193"],
[54.8560212667, 82.3943255167, "1209"],
[54.8600963167, 82.39687755, "1262A"],
[54.8619671667, 82.398902, "1292"],
[54.8647795167, 82.4015556333, "1328A"],
[54.8641711, 82.40119575, "1328B"],
[54.8653665667, 82.4021896833, "1328"],
[54.8664159, 82.4057836, "1343"],
[54.8487010667, 82.3828026833, "1084B"],
[54.8487082, 82.3838392667, "1095"],
[54.84854995, 82.3826141833, "1084A"],
[54.8614933, 82.3962749667, "1262C"],
[54.8941389333, 82.4685426667, "1A"],
[54.8940808333, 82.46863395, "1C"],
[54.8941101167, 82.46858455, "1B"],
[54.8828690833, 82.4756987833, "2"],
[54.8829161167, 82.4758464333, "3"],
[54.8828703333, 82.47600365, "4"],
[54.8826165, 82.4759774167, "5"],
[54.8827374, 82.4756385167, "1"],
[54.8987844, 82.5778468, "196"],
[54.894548, 82.5752196167, "249"],
[54.8985254833, 82.5770166167, "3/207"],
[54.8979621333, 82.5725676167, "1/207"],
[54.9028557167, 82.5775770667, "1/159"],
[54.8968063833, 82.5714292167, "2/209"],
[54.8982935667, 82.5770144167, "4/207"],
[54.9069320167, 82.5687670833, "57"],
[54.89817425, 82.5708251167, "2/207"],
[54.90506995, 82.5738151167, "103"],
[54.9103484333, 82.57042275, "15"],
[54.8938830167, 82.57586675, "1/253"],
[54.8936416667, 82.5760817333, "2/253"],
[54.90255875, 82.5776407833, "2/159"],
[54.9004225167, 82.57797105, "178"],
[54.8969604, 82.5723327, "1/209"],
[54.8767003833, 82.4818637833, "31"],
[54.8757476333, 82.4817359, "21A"],
[54.87485205, 82.4797409167, "8"],
[54.87404295, 82.47989395, "5B"],
[54.8752598667, 82.4811949, "15A"],
[54.8760220833, 82.4807411167, "18A"],
[54.8743084667, 82.4802727, "7A"],
[54.8738682667, 82.4797568167, "3C"],
[54.8742434333, 82.47987315, "5A"],
[54.8759584333, 82.4806079667, "16A"],
[54.87510295, 82.48015575, "12"],
[54.8748438833, 82.48075465, "11A"],
[54.8763291167, 82.4819017667, "27"],
[54.8763574333, 82.4822859833, "29A"],
[54.8751449333, 82.48070945, "13"],
[54.8761885667, 82.4822191333, "27A"],
[54.8746679833, 82.4804258667, "9A"],
[54.87496675, 82.4808899333, "13A"],
[54.8757570833, 82.4808296833, "16"],
[54.8758986833, 82.4809562833, "18"],
[54.87612285, 82.4811980333, "20"],
[54.87624255, 82.4813098333, "22"],
[54.8748282667, 82.47948305, "4"],
[54.875127, 82.47954055, "6"],
[54.8765282333, 82.4819416667, "29"],
[54.87591735, 82.48192895, "23"],
[54.8759485667, 82.4815328667, "21"],
[54.87574945, 82.4813294167, "19"],
[54.8742483167, 82.4796583833, "3A"],
[54.8745132, 82.4795744833, "3"],
[54.8744832833, 82.4792603167, "1"],
[54.8745364667, 82.4798557, "5"],
[54.8746295, 82.4801628, "7"],
[54.8747969, 82.480295, "9"],
[54.8745014333, 82.48041985, "9B"],
[54.8740439, 82.4796883833, "3B"],
[54.8764163833, 82.48148435, "24"],
[54.8753753333, 82.4813299167, "17A"],
[54.8749682667, 82.4800068, "10"],
[54.8761475667, 82.481741, "25"],
[54.8755644, 82.4811591833, "17"],
[54.8753512333, 82.4809225, "15"],
[54.87494615, 82.4804919833, "11"],
[54.87563925, 82.4816151667, "19A"],
[54.8755416, 82.4806192667, "14"],
[54.9307413833, 82.4305783833, "8"],
[54.9316973167, 82.4500289833, "174"],
[54.9312246333, 82.4509272167, "183"],
[54.9317041167, 82.4519870667, "192"],
[54.9309645833, 82.4455487, "131"],
[54.9313707333, 82.4417409833, "106"],
[54.93144905, 82.4439987167, "124"],
[54.9312471833, 82.44044115, "90"],
[54.9310525167, 82.4572123333, "249"],
[54.9304025833, 82.4600948, "271"],
[54.9313988167, 82.4667548167, "330"],
[54.9317416, 82.4711342333, "370"],
[54.9311057, 82.4496502333, "171"],
[54.9307743333, 82.46711525, "333"],
[54.8983426, 82.4726432167, "6"],
[54.8982667833, 82.4723224167, "10"],
[54.8981903, 82.4719677667, "14"],
[54.8981034667, 82.478259, "16"],
[54.8979483667, 82.47163995, "18"],
[54.8978498167, 82.4718887667, "9"],
[54.89804025, 82.4727496, "1"],
[54.8978692667, 82.4717117333, "11"],
[54.8982294833, 82.4721665, "12"],
[54.8983239333, 82.4724718833, "8"],
[54.89833275, 82.4728329, "4"],
[54.89817045, 82.4730263833, "2"],
[54.8979749667, 82.4721439333, "7"],
[54.8978645167, 82.4723602833, "5"],
[54.8980527833, 82.4724426, "3"],
[54.9118492167, 82.4777301333, "75"],
[54.9071599667, 82.48024025, "27A"],
[54.9070499833, 82.4802823167, "27"],
[54.9133935, 82.477312, "101"],
[54.9109577667, 82.4792493167, "58A"],
[54.907982667, 82.4798474167, "35"],
[54.9057049167, 82.48129845, "18"],
[54.9045409833, 82.4821761, "8A"],
[54.9132981167, 82.47734815, "99"],
[54.9151731167, 82.4762851667, "115A"],
[54.9159149667, 82.4765031667, "128A"],
[54.9160620833, 82.4770954, "126"],
[54.91362925, 82.4775332333, "96"],
[54.9161206833, 82.47737745, "124"],
[54.9138744167, 82.4774362833, "98"],
[54.9159982167, 82.4768568, "126A"],
[54.9045271167, 82.4818595, "8"],
[54.9088441167, 82.4798303833, "40"],
[54.9080257833, 82.4798009667, "37"],
[54.9118080833, 82.4780394667, "73"],
[54.9120441667, 82.4783650167, "80"],
[54.9142880667, 82.4768798167, "107B"],
[54.9159508833, 82.4774919167, "122A"],
[54.9050646333, 82.4819231333, "14A"],
[54.9066002, 82.4808875, "28A"],
[54.90519225, 82.4815441667, "16"],
[54.91452115, 82.477165, "106"],
[54.90746095, 82.4804961333, "32"],
[54.91248555, 82.47814135, "86"],
[54.9158230167, 82.4760962167, "123"],
[54.9159919, 82.47604385, "125"],
[54.91623445, 82.4763621, "130"],
[54.90872535, 82.4791772, "41A"],
[54.9044587, 82.4821471167, "6A"],
[54.9075026667, 82.4797328167, "33A"],
[54.9109141167, 82.4788989667, "58"],
[54.9048600833, 82.4817091833, "12"],
[54.9156691333, 82.4761731833, "121"],
[54.9159156667, 82.4772401333, "120"],
[54.9158559667, 82.4770386667, "118"],
[54.9153897167, 82.4763100667, "117"],
[54.9155261333, 82.4762367333, "119"],
[54.9143680667, 82.4772159833, "104"],
[54.9091816833, 82.4799197, "44A"],
[54.9063697833, 82.4811747, "26B"],
[54.9055854667, 82.4813526667, "18B"],
[54.9140346667, 82.4774023333, "100"],
[54.9160233167, 82.4772866833, "122B"],
[54.9046896833, 82.4817846667, "10"],
[54.9078630333, 82.4802907167, "34"],
[54.9074586667, 82.4800447667, "31"],
[54.90766965, 82.4799655333, "33"],
[54.9121775667, 82.4782823667, "82"],
[54.91233785, 82.4782158167, "84"],
[54.9135061167, 82.47759595, "92"],
[54.9141940333, 82.4769194, "107A"],
[54.9047462167, 82.4820914167, "10A"],
[54.9071456333, 82.4806193333, "30"],
[54.9126591, 82.4780602, "88"],
[54.9043394833, 82.4819642167, "6"],
[54.9136969, 82.47784185, "96A"],
[54.9162752167, 82.4761951167, "132"],
[54.9120850833, 82.4778879333, "77"],
[54.9072933667, 82.48012235, "29"],
[54.9058775167, 82.4812227667, "20"],
[54.9060436, 82.48114975, "22"],
[54.90620285, 82.4810768167, "24"],
[54.9063685833, 82.4809921833, "26"],
[54.9065447667, 82.4809131167, "28"],
[54.91495335, 82.47652165, "111"],
[54.9087348, 82.4794214667, "41"],
[54.9089801333, 82.47978555, "42"],
[54.9089057333, 82.4793457667, "43"],
[54.9095931667, 82.4790578, "51"],
[54.9123723167, 82.4777452667, "81"],
[54.9126095167, 82.47765015, "91"],
[54.91277265, 82.4775717667, "93"],
[54.91509955, 82.4768812333, "110"],
[54.9152698333, 82.476794, "112"],
[54.9154395, 82.4767326333, "114"],
[54.91572125, 82.4765971833, "116"],
[54.9102388667, 82.47919135, "50"],
[54.9048902, 82.4819941833, "12A"],
[54.9091995333, 82.47891055, "47A"],
[54.9150900667, 82.4764547333, "113"],
[54.91524275, 82.4763963833, "115"],
[54.9094314833, 82.4791159333, "49"],
[54.9096957667, 82.4794569, "48A"],
[54.9091736667, 82.4796928333, "44"],
[54.9104137167, 82.4791214333, "52"],
[54.9095526333, 82.47951535, "48"],
[54.9092440667, 82.4791909833, "47"],
[54.905025, 82.4816333, "14"],
[54.91218695, 82.4778348667, "77A"],
[54.9105796, 82.4790363667, "54"],
[54.9142164167, 82.4773281, "102"],
[54.9093673833, 82.4796006833, "46"],
[54.9107540667, 82.4789564333, "56"],
[54.9090764333, 82.4792701333, "45"],
[54.9122119833, 82.4774975, "79"],
[54.9051519, 82.4770494, "5/37B"],
[54.9072341833, 82.4812645, "74"],
[54.90539015, 82.47753615, "21/37B"],
[54.9064404833, 82.4786360667, "52"],
[54.9053830667, 82.4751337333, "28"],
[54.9053326, 82.4740749833, "20A"],
[54.9055134833, 82.4740488, "20C"],
[54.90547225, 82.4739782, "20B"],
[54.9053470167, 82.4742053667, "20D"],
[54.9069486333, 82.4814998167, "73"],
[54.9051562667, 82.4778512167, "17/37B"],
[54.9052251333, 82.4746236833, "24"],
[54.9053746, 82.4777257833, "19/37B"],
[54.9071479667, 82.4809996833, "72"],
[54.9050343167, 82.47739, "24/37B"],
[54.9049808, 82.4775142667, "25/37B"],
[54.9051211333, 82.4773504667, "23/37B"],
[54.9068252833, 82.4810905167, "69"],
[54.9047089333, 82.4739594, "19"],
[54.9040900833, 82.4718856167, "1"],
[54.9048747833, 82.4744885333, "23"],
[54.90479065, 82.4742263667, "21"],
[54.905018, 82.47392355, "16"],
[54.9063578667, 82.4783819333, "50"],
[54.9049504167, 82.4747584333, "25"],
[54.9050288833, 82.47502195, "27"],
[54.9072899333, 82.48271985, "85"],
[54.9054541333, 82.4776966667, "20/37B"],
[54.90488845, 82.4772389833, "27/37B"],
[54.9047877333, 82.4775819667, "13/37B"],
[54.9049796, 82.4771942833, "28/37B"],
[54.9073132333, 82.4815289167, "76"],
[54.9050827, 82.47699535, "6/37B"],
[54.9061134667, 82.4770216167, "40A"],
[54.90611365, 82.4768269667, "38B"],
[54.9076197, 82.4825873167, "84"],
[54.9070038333, 82.4817050667, "75"],
[54.9047039333, 82.47730165, "11/37B"],
[54.9075484833, 82.4823327833, "82"],
[54.9054264167, 82.4753033833, "30"],
[54.9069885833, 82.47905425, "58"],
[54.906228, 82.477926, "48"],
[54.9058200667, 82.4765282833, "32"],
[54.9046413667, 82.4737464333, "17"],
[54.9050075333, 82.4778885167, "16/37B"],
[54.90499485, 82.4768944167, "7/37B"],
[54.9046556167, 82.4771346, "10/37B"],
[54.90527195, 82.47690975, "1/37B"],
[54.9052758833, 82.4771711833, "3/37B"],
[54.9052169, 82.4771015167, "4/37B"],
[54.90529785, 82.4770102333, "2/37B"],
[54.9058489333, 82.47780495, "45"],
[54.9048925167, 82.4769351667, "8/37B"],
[54.9043826, 82.4728787667, "15"],
[54.9049060333, 82.47352905, "12"],
[54.9056042667, 82.47696875, "37"],
[54.9049538167, 82.47372635, "14"],
[54.9048069667, 82.4730782, "10"],
[54.90405505, 82.4727157833, "11"],
[54.9043442, 82.4726702333, "13"],
[54.9039020833, 82.4723256667, "5"],
[54.9046807667, 82.4726619167, "6"],
[54.9047340667, 82.47286755, "8"],
[54.9050737, 82.4741203667, "18"],
[54.90621865, 82.47643995, "34"],
[54.9055253667, 82.4767246667, "35"],
[54.9062645167, 82.4765613333, "36"],
[54.9059193, 82.4768274667, "38"],
[54.90570735, 82.4773252333, "39"],
[54.9059801833, 82.4770579, "40"],
[54.9062604167, 82.4772333833, "42B"],
[54.9057853667, 82.4775903, "43"],
[54.9061028167, 82.4774772667, "44"],
[54.90589465, 82.47796755, "47"],
[54.9068853333, 82.48130165, "71"],
[54.9071345833, 82.4821319833, "79"],
[54.9074696333, 82.4820778, "80A"],
[54.90765195, 82.4820632833, "80B"],
[54.9071948, 82.4823366167, "81"],
[54.90725725, 82.4825442, "83"],
[54.9042386667, 82.4723893667, "7"],
[54.9049427667, 82.47739025, "26/37B"],
[54.9048325667, 82.4777169, "14/37B"],
[54.9048868, 82.4778717167, "15/37B"],
[54.9052664833, 82.4777734333, "18/37B"],
[54.9053551, 82.4774051333, "22/37B"],
[54.90398685, 82.4726027167, "9"],
[54.9047089333, 82.4770192, "9/37B"],
[54.9061652333, 82.4777069667, "46"],
[54.9067892667, 82.4808744667, "67"],
[54.9068334667, 82.47996825, "66"],
[54.9067120833, 82.4795692, "60"],
[54.9041594, 82.4721355, "3"],
[54.9046192333, 82.4724616667, "4"],
[54.9050749, 82.47524375, "29"],
[54.9068698, 82.4786657833, "54"],
[54.9057202, 82.4762706, "32B"],
[54.9051451333, 82.4743827, "22"],
[54.90625565, 82.4769934167, "40B"],
[54.90604295, 82.4772728667, "42A"],
[54.9047528, 82.4774456167, "12/37B"],
[54.9073914, 82.4817937167, "78"],
[54.9070766667, 82.4819295333, "77"],
[54.8755341, 82.4678237, "7"],
[54.87529185, 82.467879, "5"],
[54.8751691333, 82.4682586333, "6"],
[54.8759656, 82.4679058667, "13"],
[54.87506995, 82.4678763667, "3"],
[54.8749979833, 82.46825515, "4"],
[54.8748353667, 82.4678732833, "1"],
[54.8755232, 82.4682126833, "10"],
[54.87481615, 82.4682566167, "2"],
[54.8759362, 82.4677101333, "11"],
[54.8756999, 82.4681576833, "12"],
[54.87587545, 82.4680599833, "14"],
[54.8753491, 82.4682464333, "8"],
[54.8757606333, 82.46762115, "9"],
[54.8187813333, 82.5099677833, "62"],
[54.81924235, 82.5087604667, "49"],
[54.8177396167, 82.5119011167, "86"],
[54.8178875667, 82.51156545, "84"],
[54.8174387167, 82.51263255, "90"],
[54.83408825, 82.55531685, "1/1101"],
[54.882450333, 82.51885165, "150"],
[54.8077506333, 82.541635, "400"],
[54.8136809, 82.5290861, "265"],
[54.8110874, 82.53251965, "304"],
[54.8095875, 82.5753655167, "2/729"],
[54.83343, 82.5554701333, "1101"],
[54.8173373833, 82.5201625167, "160"],
[54.80918625, 82.5753678333, "1/729"],
[54.8101949167, 82.5340213667, "320"],
[54.8114688333, 82.5313781167, "299"],
[54.8110666833, 82.5317111833, "301"],
[54.8174875833, 82.5162427833, "126"],
[54.8121336833, 82.5303464167, "289"],
[54.8180013167, 82.5178742, "2/138"],
[54.81761695, 82.51742335, "1/138"],
[54.8074874667, 82.5440482, "430"],
[54.80752155, 82.5425832333, "416"],
[54.8366309333, 82.5496806333, "1173"],
[54.8169579833, 82.5214218667, "179"],
[54.8298305, 82.5634204, "1007"],
[54.8149217167, 82.5283630333, "247"],
[54.8217308333, 82.5663090333, "910"],
[54.81460935, 82.5745359167, "797"],
[54.8234203333, 82.5658778, "924"],
[54.8319167167, 82.5559498, "1086"],
[54.8306048167, 82.5616193833, "1023"],
[54.8828865, 82.57007665, "851"],
[54.8329407, 82.55562365, "1099"],
[54.81693675, 82.5123568167, "95"],
[54.8182193, 82.5131360833, "88"],
[54.8130308833, 82.5297032667, "273"],
[54.8095776, 82.55597085, "544"],
[54.8072376833, 82.5452215833, "443"],
[54.81966705, 82.5090003167, "48"],
[54.8169615333, 82.5198118833, "159"],
[54.8169314, 82.51421915, "112"],
[54.8080136167, 82.5463236, "452"],
[54.807907, 82.5458772167, "448"],
[54.80796455, 82.5461119167, "450"],
[54.8168847833, 82.5220721833, "181"],
[54.8354269, 82.5522720333, "1145"],
[54.83545425, 82.5543820167, "1129"],
[54.8082469167, 82.5385727167, "376"],
[54.8076848, 82.5419475167, "408"],
[54.8162252667, 82.5265092167, "225"],
[54.8166361333, 82.52144, "1/179"],
[54.8070565833, 82.5441373667, "429"],
[54.8075943333, 82.5444878167, "432"],
[54.8221778667, 82.5667572, "911"],
[54.8179158667, 82.5105938667, "73"],
[54.807556, 82.5460459333, "447"],
[54.8080632333, 82.5465634, "454"],
[54.8070305833, 82.54991865, "483"],
[54.80831265, 82.5514465667, "526"],
[54.80744605, 82.5634000833, "603"],
[54.8164026833, 82.5278071167, "234"],
[54.80656415, 82.5705962833, "665"],
[54.81898205, 82.5685284167, "862"],
[54.8236973167, 82.56648815, "927"],
[54.8256295833, 82.5653636167, "965"],
[54.8142507167, 82.57521965, "789"],
[54.8094723167, 82.5346592, "349"],
[54.8098434333, 82.5333155167, "319"],
[54.8292230167, 82.5635525167, "1005"],
[54.8173514167, 82.5221399167, "180"],
[54.83840865, 82.5469221167, "1213"],
[54.8379536333, 82.5475567833, "1201"],
[54.81720545, 82.5149902333, "116"],
[54.8085928833, 82.5380488, "370"],
[54.80779995, 82.5386938833, "379"],
[54.8204958333, 82.50876015, "34"],
[54.82623815, 82.56358455, "970"],
[54.81448725, 82.5734910333, "804"],
[54.8222833167, 82.5659173667, "912"],
[54.8170449333, 82.5277756167, "1/232"],
[54.8176035333, 82.5269654167, "2/232"],
[54.8323760333, 82.5575159333, "1078"],
[54.83021075, 82.5612354667, "1024"],
[54.9305489, 82.5017878333, "90"],
[54.93116365, 82.5055481833, "122"],
[54.9319767167, 82.5109385, "168"],
[54.93029815, 82.4998441167, "72"],
[54.9291897167, 82.4957679, "35"],
[54.92986625, 82.4972463167, "50"],
[54.9290868833, 82.4948005167, "25"],
[54.9296040667, 82.4987881667, "63"],
[54.9309512167, 82.5043885167, "110"],
[54.9296868833, 82.4958722667, "38"],
[54.9295072167, 82.4977275833, "51"],
[54.9303624833, 82.5006042333, "74"],
[54.9319759, 82.5106025, "166"],
[54.9306431833, 82.5024661, "96"],
[54.9299079167, 82.4976426667, "52"],
[54.9312659333, 82.5064569833, "132"],
[54.93082875, 82.50372585, "106"],
[54.9320732833, 82.5108069, "167"],
[54.8443465167, 82.36530835, "32"],
[54.8448259333, 82.3650265167, "36"],
[54.8425576167, 82.3664466333, "8"],
[54.8925954833, 82.45710755, "3"],
[54.8930169167, 82.45739025, "13"],
[54.89310595, 82.4574966167, "17"],
[54.8931706667, 82.4571386, "19"],
[54.8930694833, 82.45792925, "15"],
[54.892484, 82.4570883333, "1"],
[54.8926542167, 82.4574440667, "5"],
[54.89269795, 82.4575341667, "7"],
[54.8926711333, 82.4579661, "9"],
[54.8929884833, 82.4571287, "11"],
[54.883121, 82.4810597, "11"],
[54.8827995833, 82.4808762167, "15"],
[54.8827993, 82.4810446833, "15A"],
[54.88305445, 82.4806939167, "14"],
[54.8832812833, 82.4806736333, "12"],
[54.8829723, 82.4809516, "13"],
[54.8836668, 82.4806524333, "8"],
[54.88350115, 82.4806812167, "10"],
[54.8838327667, 82.4806120333, "6"],
[54.8836368, 82.4810848667, "5"],
[54.8840162333, 82.4806070667, "4"],
[54.8841447, 82.4806001167, "2"],
[54.8837898, 82.4810769333, "3"],
[54.8834789167, 82.4810792167, "7"],
[54.8832999833, 82.4810661333, "9"],
[54.8839425333, 82.4810822667, "1"],
[54.8741644333, 82.466663, "1"],
[54.8741701833, 82.4671011667, "2"],
[54.8734758833, 82.4661548667, "11B"],
[54.8730602167, 82.4660412333, "17B"],
[54.8732532833, 82.4669407833, "12"],
[54.8736860667, 82.4670495333, "8"],
[54.8738914, 82.4662481167, "5B"],
[54.8740275667, 82.46708325, "4"],
[54.8728965, 82.4668399167, "16"],
[54.87401705, 82.4666682333, "3"],
[54.8740028333, 82.4662564, "5A"],
[54.8734885167, 82.467, "10"],
[54.8738630833, 82.4670664333, "6"],
[54.8737826, 82.4666489667, "7"],
[54.8735874, 82.46617485, "11A"],
[54.8736024167, 82.4666129, "9"],
[54.8730790167, 82.4668945167, "14"],
[54.8729272167, 82.4664146833, "19"],
[54.8733468333, 82.4665393167, "13"],
[54.8731517, 82.4664815167, "15"],
[54.8731441167, 82.4660683, "17A"],
[54.8825944667, 82.4798169833, "2"],
[54.8826055167, 82.4805495667, "10"],
[54.8825809333, 82.4800131333, "4"],
[54.8825441333, 82.4804278333, "8"],
[54.8828469, 82.4800110667, "3"],
[54.882842, 82.4802305333, "5"],
[54.8825584833, 82.4801972667, "6"],
[54.8828376, 82.4804269167, "7"],
[54.88275275, 82.4805278667, "9"],
[54.8828507833, 82.4798377667, "1"],
[54.8747543667, 82.3655736, "277"],
[54.8779646667, 82.3771985, "389"],
[54.8791017167, 82.3701385167, "1/326"],
[54.8809893667, 82.38422785, "458"],
[54.8801277667, 82.3840239333, "459"],
[54.8814240333, 82.3849688833, "468"],
[54.8806415333, 82.38358955, "452"],
[54.8785101, 82.3802812167, "409"],
[54.8796759167, 82.3830951167, "445"],
[54.8803115167, 82.3830208833, "446"],
[54.8778165333, 82.3759684833, "373"],
[54.88137445, 82.3862355333, "473"],
[54.8782752833, 82.3789725, "397"],
[54.8808287667, 82.3851571, "469"],
[54.87896095, 82.3695827167, "326"],
[54.8765604833, 82.3662541167, "288"],
[54.8818931667, 82.38581595, "474"],
[54.8775986, 82.3747133333, "2/359"],
[54.8769582833, 82.3713375, "331"],
[54.8843103667, 82.3914426833, "531"],
[54.87595675, 82.3649699833, "271"],
[54.8781325, 82.3739238833, "356"],
[54.8763472667, 82.36476045, "270"],
[54.87676475, 82.3676648667, "298"],
[54.8769505833, 82.36918955, "310"],
[54.8766704667, 82.36975, "313"],
[54.8777166, 82.3720850333, "334"],
[54.8773668333, 82.3733521333, "349"],
[54.8772966667, 82.3744940833, "1/359"],
[54.87831085, 82.3791264167, "399"],
[54.8778886833, 82.37662545, "377"],
[54.8784267667, 82.3770323833, "388"],
[54.8790059333, 82.3798270667, "408"],
[54.91994325, 82.4698456167, "5"],
[54.9200047, 82.4693797833, "6"],
[54.9195710333, 82.4694752833, "2"],
[54.9203742667, 82.4697562833, "7"],
[54.9196343, 82.4699295667, "3"],
[54.9198162, 82.4690209, "4"],
[54.8824037833, 82.4600990333, "5"],
[54.88208185, 82.4598317167, "9"],
[54.8826121667, 82.4600836333, "3"],
[54.8826033333, 82.45961605, "2"],
[54.8822431167, 82.4600865, "7"],
[54.8821465833, 82.4595746, "8"],
[54.8823125667, 82.45958745, "6"],
[54.8824702667, 82.4595934167, "4"],
[54.9092579167, 82.46735845, "6A"],
[54.9089322167, 82.4674924, "10"],
[54.90894585, 82.4672735167, "12"],
[54.9089078333, 82.46711725, "11"],
[54.9089631667, 82.4669939667, "9"],
[54.90904455, 82.4673255, "8"],
[54.9094559, 82.4668010167, "1"],
[54.9093255, 82.4673469667, "4A"],
[54.9093457833, 82.46717355, "4"],
[54.9095302167, 82.4670570667, "2"],
[54.9090935, 82.4664936667, "3"],
[54.90917125, 82.4672602333, "6"],
[54.90908325, 82.4669295667, "7"],
[54.9092908333, 82.4668895333, "5"],
[54.8593663833, 82.4539760167, "251"],
[54.8754824, 82.4604578167, "63"],
[54.8750289833, 82.4602931333, "67"],
[54.7985084167, 82.4478579333, "941"],
[54.842417, 82.4531796833, "443"],
[54.8085080333, 82.45099665, "810"],
[54.79048555, 82.44243815, "1063"],
[54.8492731667, 82.4532494833, "355"],
[54.8094198833, 82.4503523667, "819"],
[54.8728692167, 82.4594153667, "91"],
[54.8522977333, 82.4539347833, "344"],
[54.8484041333, 82.45409895, "372"],
[54.8479726833, 82.45304965, "387"],
[54.7948086, 82.4476616833, "994"],
[54.7914089, 82.4452872333, "1027"],
[54.8080105, 82.4498779333, "835"],
[54.8722349333, 82.459282167, "99"],
[54.8091485667, 82.45085495, "821"],
[54.8594542833, 82.4549678833, "5/246"],
[54.8230668667, 82.4541309833, "660"],
[54.8316753333, 82.4539613167, "562"],
[54.8387429833, 82.4531928, "475"],
[54.8545740667, 82.4540875333, "294"],
[54.7900112167, 82.4442665, "1045"],
[54.8172833167, 82.4539773167, "724"],
[54.83503155, 82.453934, "542"],
[54.8607128667, 82.4548002, "2/241"],
[54.8380142833, 82.45391425, "490"],
[54.8275037167, 82.4529093833, "589"],
[54.8596196, 82.4542151, "249"],
[54.8595530167, 82.45479165, "3/246"],
[54.85959605, 82.45471705, "2/246"],
[54.8592503167, 82.4544837333, "252"],
[54.8713457667, 82.4587725833, "111"],
[54.8595053, 82.4548791833, "4/246"],
[54.79668195, 82.4482608333, "958"],
[54.8227231, 82.4540730167, "670"],
[54.8750904833, 82.4593735333, "71"],
[54.8190378833, 82.4540990167, "702"],
[54.86957775, 82.4580359, "129"],
[54.8662393833, 82.4567130667, "169"],
[54.8687158167, 82.4577150333, "141"],
[54.86791495, 82.4573792167, "151"],
[54.8089932167, 82.4507184167, "823"],
[54.8666422833, 82.4569389667, "167"],
[54.8738722833, 82.4598649833, "81"],
[54.8169442833, 82.4534629333, "727"],
[54.8185275, 82.4534621333, "709"],
[54.8059395833, 82.44899615, "859"],
[54.8327434833, 82.4540100333, "550"],
[54.8604312833, 82.4546856333, "1/241"],
[54.8610548833, 82.4549434167, "3/241"],
[54.8596720667, 82.4547582, "244"],
[54.8603010167, 82.4551234333, "238"],
[54.874473, 82.4600767667, "75"],
[54.8192958833, 82.4546863, "698"],
[54.80070935, 82.4483520333, "917"],
[54.8595345, 82.4546793167, "250"],
[54.8395576167, 82.4538942167, "470"],
[54.8600606333, 82.4551961167, "242"],
[54.8587876, 82.45357305, "261"],
[54.8202505167, 82.454168, "692"],
[54.83062305, 82.4541314, "574"],
[54.85965015, 82.4546251667, "1/246"],
[54.87094345, 82.4585491667, "115"],
[54.82367025, 82.4541148167, "654"],
[54.8761585333, 82.4607254667, "55"],
[54.8650849833, 82.4562546333, "183"],
[54.8104551333, 82.45176685, "803"],
[54.8601735167, 82.4545659833, "247"],
[54.8072936667, 82.4501624667, "842"],
[54.81121545, 82.4523795667, "795"],
[54.8082023667, 82.4500136333, "833"],
[54.8088097833, 82.4505667167, "825"],
[54.8073512333, 82.4494723833, "841"],
[54.8180043167, 82.45347675, "713"],
[54.8034810667, 82.44930745, "884A"],
[54.8133904167, 82.4533446667, "767"],
[54.7906012833, 82.4456008, "1032"],
[54.8036063333, 82.44934055, "884"],
[54.8086218, 82.4503990167, "827"],
[54.7990523833, 82.4480464, "931"],
[54.8435690667, 82.40554535, "296A"],
[54.84511005, 82.4057523167, "282"],
[54.8456481333, 82.4283544, "93"],
[54.8452106, 82.4213902167, "154"],
[54.8456685667, 82.4217703833, "151"],
[54.8450910333, 82.4066185167, "296B"],
[54.84556515, 82.3859519, "471"],
[54.8456769, 82.4356176167, "29"],
[54.8452146333, 82.4326596167, "54"],
[54.8456379667, 82.4318747833, "59"],
[54.8451947667, 82.4291500167, "82"],
[54.8456449667, 82.42712405, "103"],
[54.8452215333, 82.4202044833, "166"],
[54.84562355, 82.4192034833, "173"],
[54.84520295, 82.4171995667, "190"],
[54.8451047667, 82.4159582, "204"],
[54.84557985, 82.4160677, "201"],
[54.8451894667, 82.4139933167, "218"],
[54.8455275833, 82.4075856833, "277"],
[54.8455757667, 82.40668145, "281"],
[54.8451309667, 82.4038956667, "308"],
[54.8455923333, 82.40336095, "313"],
[54.8451457333, 82.4006193, "332"],
[54.8456046667, 82.3996052667, "345"],
[54.8450766, 82.3979973833, "362A"],
[54.8450326167, 82.3961487833, "376"],
[54.84556585, 82.3949421167, "389"],
[54.84503405, 82.3928639333, "406"],
[54.8450819, 82.3938952833, "398"],
[54.8449702833, 82.39000315, "430"],
[54.8455388, 82.3929698833, "403"],
[54.8455067667, 82.389923, "431"],
[54.8449729167, 82.38231105, "498"],
[54.8449880833, 82.38162075, "502"],
[54.8432495, 82.3824779667, "496"],
[54.8441658167, 82.4248163667, "122"],
[54.84258355, 82.3809411333, "512"],
[54.8451205833, 82.41321575, "228"],
[54.8454313833, 82.3813477333, "509"],
[54.8449337333, 82.3830211333, "494"],
[54.8456650333, 82.4344218333, "1/41"],
[54.8450306667, 82.3974560667, "362C"],
[54.8463207667, 82.4343822167, "2/42"],
[54.8450416833, 82.3967473667, "372"],
[54.8455358167, 82.4085091, "267"],
[54.8451470333, 82.4076077167, "276"],
[54.84420195, 82.39791495, "362B"],
[54.8452185667, 82.4259005667, "114"],
[54.8456212833, 82.4347298667, "39"],
[54.8452003167, 82.40904765, "262"],
[54.8451996667, 82.4122621833, "234"],
[54.84515415, 82.4098542167, "256"],
[54.8455715833, 82.4139006833, "223"],
[54.8455915333, 82.4136348333, "225"],
[54.8455279667, 82.3870696, "463"],
[54.8457080167, 82.4225169667, "145"],
[54.8450449333, 82.3784177833, "536"],
[54.8441582, 82.3843482, "480"],
[54.8441567667, 82.38280735, "494A"],
[54.8450534333, 82.3804865833, "516"],
[54.845458, 82.3819993833, "503"],
[54.8416720667, 82.4161419167, "202"],
[54.84561615, 82.4169546167, "193"],
[54.8456090833, 82.4248031, "127"],
[54.8452347167, 82.4210866, "156"],
[54.8452366333, 82.4236209667, "136"],
[54.8420864167, 82.3808174, "514"],
[54.9352309167, 82.4932222, "138"],
[54.9344554333, 82.48793725, "92"],
[54.93352515, 82.48479765, "59"],
[54.9333442833, 82.4806992167, "30"],
[54.9333265, 82.4832372833, "43"],
[54.9338463667, 82.4867482, "81"],
[54.9349315333, 82.4913314333, "109"],
[54.9335968833, 82.4853604, "63"],
[54.9316883, 82.48456045, "53"],
[54.9338528333, 82.4839506, "52"],
[54.8310454167, 82.5756857833, "775"],
[54.8312273667, 82.5775630667, "757"],
[54.8293654833, 82.5685721667, "851"],
[54.8285495833, 82.56486995, "881"],
[54.8309590333, 82.5733609, "801"],
[54.8305305333, 82.5736851833, "790"],
[54.8295682333, 82.56931885, "841"],
[54.83130275, 82.5782757167, "753"],
[54.8283176167, 82.5655312333, "879"],
[54.8540068167, 82.37670555, "34"],
[54.85430545, 82.3768498167, "32"],
[54.8549918167, 82.3798488333, "5"],
[54.85449605, 82.37689005, "33"],
[54.8547125333, 82.3802214167, "4"],
[54.8545867833, 82.3781517833, "28"],
[54.8547440667, 82.37743325, "31"],
[54.85420255, 82.3773112333, "30"],
[54.8879053333, 82.5233262333, "1/18"],
[54.8881771333, 82.5232950167, "2/18"],
[54.8834455333, 82.45836535, "92"],
[54.8863947167, 82.4586610667, "58B"],
[54.8866006667, 82.45961975, "55A"],
[54.8867239167, 82.4592584167, "55"],
[54.88667, 82.4586812, "56"],
[54.8817044333, 82.4588333167, "113"],
[54.8815483333, 82.4587898667, "115"],
[54.8814229167, 82.4587740833, "117"],
[54.8913856667, 82.4590918167, "18"],
[54.8915707667, 82.4591145167, "16"],
[54.8868740833, 82.4599066167, "53C"],
[54.88889255, 82.4599269833, "37B"],
[54.89262475, 82.4600617167, "7A"],
[54.8889847167, 82.4594067667, "37A"],
[54.8925890833, 82.4585589, "10B"],
[54.8824604, 82.4588691333, "105"],
[54.8836036333, 82.4583701, "90"],
[54.8908670667, 82.4585197333, "24A"],
[54.8826975167, 82.4583391, "98"],
[54.8835235167, 82.4590010333, "95"],
[54.8838230333, 82.4583829333, "88"],
[54.8845143667, 82.4579167, "80A"],
[54.8828394333, 82.4583557667, "96"],
[54.88251835, 82.4583208667, "100"],
[54.8926768167, 82.4583797667, "10C"],
[54.88716595, 82.4586927333, "50"],
[54.8883195667, 82.4593362333, "43"],
[54.8864967833, 82.4592373833, "59"],
[54.8871386833, 82.4592945833, "51"],
[54.8836205667, 82.4589701333, "91"],
[54.8870057667, 82.4587382167, "52"],
[54.8823566667, 82.4583266833, "102"],
[54.8867508, 82.45831015, "2/54"],
[54.88680585, 82.4583326167, "54B"],
[54.8869064, 82.4592745833, "53"],
[54.8836770667, 82.45788765, "90A"],
[54.88377685, 82.45896945, "91A"],
[54.8844059167, 82.4593669667, "83A"],
[54.8843895833, 82.4590283, "83"],
[54.88413765, 82.4580580833, "84A"],
[54.8909576167, 82.4590556833, "22"],
[54.8932342, 82.4592408833, "4"],
[54.8929272167, 82.45863745, "8B"],
[54.8929735167, 82.4583677333, "8C"],
[54.8859658167, 82.4592039, "71"],
[54.8881317333, 82.4593295333, "45"],
[54.88894835, 82.45890335, "36"],
[54.88873325, 82.4588844167, "38"],
[54.8885017167, 82.45935385, "41A"],
[54.8888022667, 82.4593873, "39"],
[54.88814385, 82.4586047333, "44A"],
[54.8854610167, 82.4585890667, "66"],
[54.89301925, 82.4597807333, "3"],
[54.8888152167, 82.4597877833, "37C"],
[54.88442445, 82.4579215333, "82A"],
[54.8841846833, 82.4584516, "84"],
[54.8858883833, 82.4596244167, "71A"],
[54.8911121167, 82.4596169167, "21"],
[54.8882564333, 82.4588584167, "42"],
[54.8839837, 82.4584101, "86"],
[54.8862705, 82.4595605667, "63"],
[54.8878208, 82.4588156833, "46"],
[54.8891674833, 82.4594178, "35"],
[54.8884817, 82.4588827667, "40"],
[54.8845497667, 82.4584736333, "80"],
[54.8908341667, 82.45958975, "23"],
[54.8926482, 82.4588475667, "10A"],
[54.8846152, 82.4590487333, "81"],
[54.8868875833, 82.4597079333, "53B"],
[54.8867661667, 82.4580206, "1/54"],
[54.8923631167, 82.4601005833, "11A"],
[54.8880116333, 82.4588415167, "44"],
[54.88179955, 82.4582856667, "108"],
[54.8819699667, 82.4588568833, "109"],
[54.8906476667, 82.4590157667, "28"],
[54.8846581333, 82.4584694833, "78"],
[54.8843345167, 82.4584402833, "82"],
[54.8841375167, 82.4590033, "85"],
[54.88394965, 82.4578898667, "86A"],
[54.88396905, 82.45758895, "86B"],
[54.8837848667, 82.4578930833, "88A"],
[54.8839426667, 82.4589834333, "89"],
[54.8923547333, 82.4596697667, "11"],
[54.8916483333, 82.45965705, "13"],
[54.89177585, 82.4591300667, "14"],
[54.8914522167, 82.459646, "15"],
[54.8912940833, 82.4596277667, "17"],
[54.8923723833, 82.4592214, "12"],
[54.8907689667, 82.4590306667, "24"],
[54.8904437833, 82.4595327, "25A"],
[54.8906071167, 82.4595718167, "25"],
[54.8902158167, 82.4595238167, "27"],
[54.8911627, 82.4590753167, "20"],
[54.8886534333, 82.4593824833, "41"],
[54.8930344167, 82.4600257833, "3A-3F"],
[54.8865167167, 82.4586738833, "58"],
[54.8863451667, 82.4592180667, "61"],
[54.88626165, 82.45980935, "65"],
[54.8862540167, 82.4586216, "60"],
[54.8858030167, 82.4586246, "62"],
[54.8856375333, 82.4586118667, "64"],
[54.89284255, 82.4600622333, "5A"],
[54.8928040667, 82.4597492333, "5"],
[54.8861293, 82.4592111833, "69"],
[54.8858680333, 82.4598526167, "71B"],
[54.885777, 82.4599270167, "71C"],
[54.8857422667, 82.4597478167, "71D"],
[54.88574365, 82.45918075, "73"],
[54.8855746833, 82.4591693833, "75"],
[54.8930622167, 82.4592157833, "6"],
[54.8925581, 82.4603171, "7B"],
[54.8926518167, 82.46025555, "7C"],
[54.8929233, 82.4588164167, "8A"],
[54.8928556667, 82.4592156833, "8"],
[54.8924033, 82.4602587333, "9"],
[54.8826857833, 82.4589041167, "103"],
[54.8868134333, 82.4586863667, "54"],
[54.8821768333, 82.4588641833, "107"],
[54.8925898333, 82.4596910333, "7"],
[54.8862095667, 82.46007345, "67"],
[54.8893183667, 82.4594386167, "33"],
[54.88182795, 82.4588519167, "111"],
[54.8853995, 82.4591325167, "77"],
[54.8819874833, 82.4582899, "106"],
[54.8868931667, 82.4594645667, "53A"],
[54.89067275, 82.4587377333, "28A"],
[54.88729905, 82.45870125, "48"],
[54.8872955667, 82.4593124, "49"],
[54.8926355167, 82.4591491667, "10"],
[54.8821580833, 82.45830775, "104"],
[54.8581124833, 82.3783852167, "535"],
[54.8652348667, 82.3746078, "454"],
[54.8528962667, 82.3764204333, "591C"],
[54.8658603333, 82.3777156333, "466B"],
[54.8561505333, 82.3796002833, "563"],
[54.8574877833, 82.3782657333, "557"],
[54.8648613667, 82.3759225833, "466A"],
[54.8680267, 82.3758790667, "422"],
[54.8679018667, 82.3731075, "420"],
[54.85081775, 82.3829343167, "643"],
[54.8671912, 82.36468055, "352"],
[54.86727615, 82.36543555, "360"],
[54.8501304, 82.3806456, "637"],
[54.8673357333, 82.3661331333, "366A"],
[54.8673979333, 82.3667809, "366B"],
[54.8526604333, 82.3775103333, "591B"],
[54.8590671, 82.3777331, "525"],
[54.8604441333, 82.37691195, "511A"],
[54.8674681167, 82.3678874333, "374"],
[54.8677148833, 82.3698444833, "402"],
[54.8666863, 82.3663322333, "365"],
[54.8675554, 82.3754905167, "424A"],
[54.8676465167, 82.37623815, "424"],
[54.86661535, 82.37609495, "442"],
[54.8598401833, 82.3771549167, "511B"],
[54.8661314333, 82.3647742667, "353"],
[54.8666274333, 82.3736697167, "434"],
[54.8662379333, 82.3738677667, "438"],
[54.8520614, 82.3823100833, "613"],
[54.8521965167, 82.3812996167, "607"],
[54.85242245, 82.3821009333, "605"],
[54.8520654833, 82.3761835667, "591A"],
[54.8547938667, 82.3751005167, "591D"],
[54.8600232, 82.3780412167, "516"],
[54.8504624833, 82.3807091333, "635B"],
[54.86694425, 82.3698350167, "387"],
[54.8512808, 82.3826955167, "635A"],
[54.8626598333, 82.3763083833, "480"],
[54.8631832667, 82.3759811, "478"],
[54.8597738, 82.3758612333, "511"],
[54.8669354833, 82.3734885833, "432"],
[54.8660254333, 82.3741769333, "440"],
[54.8677621333, 82.3708737667, "418"],
[54.86470325, 82.3749985333, "456"],
[54.8496086167, 82.3843649167, "660"],
[54.8533389167, 82.3814388333, "599"],
[54.8513108, 82.3833057167, "636"],
[54.8582031333, 82.3789229667, "536"],
[54.8049091167, 82.4582433833, "111"],
[54.79217, 82.4610993667, "235"],
[54.7912009, 82.46131515, "243"],
[54.8073855167, 82.4519374833, "17"],
[54.7901330667, 82.4618390333, "259"],
[54.7979543, 82.46169615, "186"],
[54.7953406667, 82.4605087333, "199"],
[54.8075016167, 82.4517328833, "15"],
[54.7944439333, 82.4604859167, "221"],
[54.8960575333, 82.47501025, "14"],
[54.8979342, 82.4745448, "31A"],
[54.8968049167, 82.47448785, "24A"],
[54.8974204333, 82.475026, "25"],
[54.8977612, 82.47473925, "29"],
[54.89678435, 82.4748293, "20"],
[54.89589205, 82.4749720833, "12"],
[54.8966669, 82.4743795667, "22"],
[54.8958911333, 82.4761947, "5"],
[54.8971542833, 82.4752421167, "21"],
[54.8960713, 82.4760678, "7"],
[54.8971206833, 82.47398845, "30"],
[54.8959413333, 82.4751180667, "10A"],
[54.89774365, 82.4741330667, "40"],
[54.8964759167, 82.4757599833, "13"],
[54.8956967, 82.4756972333, "6"],
[54.8969728167, 82.4746339333, "24"],
[54.8975985667, 82.4742274833, "38"],
[54.8964206167, 82.4764929, "9"],
[54.89591475, 82.4748164, "14A"],
[54.8963322333, 82.4747763333, "18A"],
[54.8962043333, 82.4746025333, "18B"],
[54.8969914833, 82.47434705, "26A"],
[54.8975744667, 82.4748792167, "27"],
[54.8979075667, 82.4740015333, "42"],
[54.89599185, 82.4754597167, "10"],
[54.89628205, 82.4758701, "11"],
[54.8966986167, 82.4755950667, "15"],
[54.8954172667, 82.4758408833, "2"],
[54.8955642833, 82.47581195, "4"],
[54.8957927167, 82.4756119833, "8"],
[54.8974439333, 82.4743467667, "36"],
[54.8954518167, 82.4753103, "6A"],
[54.89718045, 82.4745253167, "26"],
[54.89567315, 82.4763134667, "1"],
[54.8957657667, 82.4763043333, "3"],
[54.8965164667, 82.4750518, "18"],
[54.89807905, 82.47440185, "31"],
[54.8968958, 82.4754382833, "17"],
[54.89631735, 82.4752079667, "16"],
[54.8972125833, 82.4741699833, "34"],
[54.8970015667, 82.47401225, "28"],
[54.9133573833, 82.4717484667, "287"],
[54.9048133167, 82.47635, "104"],
[54.9049925, 82.4762745167, "106"],
[54.90467735, 82.4753654167, "107"],
[54.90048465, 82.4783948167, "58"],
[54.8992426833, 82.4793293167, "42"],
[54.9046434667, 82.4764180667, "102"],
[54.91292555, 82.47197745, "285"],
[54.9061096167, 82.4751589833, "127"],
[54.9059487333, 82.4760527167, "120B"],
[54.9058349, 82.4758649667, "120A"],
[54.9046025333, 82.47507605, "107A"],
[54.9043145167, 82.4765927167, "98"],
[54.9026473833, 82.4773607333, "80"],
[54.8985112833, 82.4791536, "37"],
[54.90029415, 82.4779031333, "57"],
[54.9157889333, 82.4706511667, "307"],
[54.9161504167, 82.4698894, "317"],
[54.9162483333, 82.47040295, "315"],
[54.9119694833, 82.4724158167, "273"],
[54.9127305, 82.4727451167, "280A"],
[54.910892, 82.4729321833, "257"],
[54.91104955, 82.4723925167, "261"],
[54.91155295, 82.4731748833, "260"],
[54.9104050667, 82.4728724167, "249"],
[54.91055955, 82.4730871, "251"],
[54.9074686167, 82.4751091833, "188"],
[54.9079151, 82.4751543167, "192A"],
[54.9060373, 82.4757691167, "136"],
[54.90429105, 82.4760343833, "97"],
[54.9123212333, 82.4728413167, "276"],
[54.91122575, 82.4733142333, "240"],
[54.9028192, 82.4767472833, "83"],
[54.8979333667, 82.4794421167, "31"],
[54.8977516, 82.4801524833, "28"],
[54.89934065, 82.4785610667, "47"],
[54.9103580667, 82.4731422667, "247"],
[54.9106933167, 82.4735704667, "238"],
[54.90118205, 82.4774954833, "65"],
[54.9051274833, 82.4765782667, "106A"],
[54.9001666333, 82.4786251833, "54"],
[54.8996917833, 82.4776611333, "53A"],
[54.9157449833, 82.4701549667, "311"],
[54.8998454833, 82.47809685, "53"],
[54.8999531167, 82.4780619, "55"],
[54.9123259333, 82.4731539833, "274"],
[54.91203635, 82.4729645833, "262"],
[54.9025673667, 82.4766802, "79A"],
[54.8995076667, 82.4784470167, "49"],
[54.9160592167, 82.4710586333, "316"],
[54.9045513333, 82.4752828833, "105"],
[54.901886, 82.4778055167, "74B"],
[54.9007665833, 82.4782302, "60"],
[54.9027685, 82.4767654333, "81"],
[54.9042667667, 82.47545395, "99"],
[54.90210725, 82.4776131, "76"],
[54.914356, 82.4712761333, "299"],
[54.9037502167, 82.4768480333, "94"],
[54.8975508667, 82.48021795, "22"],
[54.9126604333, 82.4720775, "281"],
[54.90140745, 82.4783687833, "66"],
[54.9008916333, 82.4774276833, "63"],
[54.91678785, 82.47071965, "322"],
[54.9088462667, 82.4738790833, "227"],
[54.9123182167, 82.4722337, "277"],
[54.90000635, 82.47873665, "52"],
[54.9015533, 82.47851885, "70"],
[54.9015025333, 82.4779211333, "72"],
[54.9159910833, 82.4705165167, "313"],
[54.9138507667, 82.4715170333, "293"],
[54.9090778667, 82.4737512667, "229"],
[54.9128195833, 82.4726191, "282"],
[54.9131350667, 82.4724749667, "286"],
[54.913967, 82.4720198833, "294"],
[54.9129905, 82.4725340833, "284"],
[54.90123535, 82.4772228667, "67"],
[54.9143479, 82.4719130833, "298"],
[54.9126444833, 82.4726878, "280"],
[54.9165660167, 82.4702721167, "323"],
[54.8989755, 82.4782464167, "45"],
[54.9093448667, 82.47364355, "233"],
[54.91447635, 82.4712330833, "301"],
[54.9095208333, 82.4735786833, "235"],
[54.9096743333, 82.4741524, "232"],
[54.89939865, 82.47921515, "44"],
[54.9151960833, 82.4709698167, "305"],
[54.9097280833, 82.4745849333, "228"],
[54.9013794667, 82.47741285, "69"],
[54.9162268667, 82.47098265, "318"],
[54.8990613333, 82.4787713333, "43"],
[54.89780295, 82.4806196167, "26"],
[54.91541455, 82.4713506833, "306"],
[54.9097875333, 82.4748558667, "228A"],
[54.9081311333, 82.4748058, "196A"],
[54.9150421333, 82.4709822167, "303"],
[54.9053254667, 82.47610225, "114"],
[54.9065445333, 82.4749703667, "173"],
[54.9098205333, 82.4741548833, "234"],
[54.9081538667, 82.4750639167, "196"],
[54.9096973, 82.4748021167, "226A"],
[54.9093885667, 82.4742162667, "224A"],
[54.9091188, 82.4743508333, "222A"],
[54.90953665, 82.4733968, "235A"],
[54.90795735, 82.4748888667, "194"],
[54.9014723, 82.47869265, "68"],
[54.9095686833, 82.4733282167, "237A"],
[54.9090926833, 82.47436235, "222"],
[54.9012697667, 82.4780105833, "64"],
[54.9165941667, 82.4699768667, "325"],
[54.8983101833, 82.4790199333, "35A"],
[54.8989313833, 82.4795513167, "38"],
[54.9020688, 82.4782522167, "74"],
[54.91629055, 82.4698086667, "321"],
[54.90362685, 82.4769062, "92"],
[54.8978983167, 82.480096, "30"],
[54.9095879, 82.4744869833, "226"],
[54.8988477333, 82.4788966333, "41"],
[54.9144792667, 82.47185395, "300"],
[54.90345575, 82.4769852667, "90"],
[54.90295525, 82.4772238333, "84"],
[54.9155634, 82.47150915, "308A"],
[54.9077980667, 82.4749606833, "192B"],
[54.9024718333, 82.47689145, "79"],
[54.9010265333, 82.4781286667, "62"],
[54.9051546167, 82.4761810167, "108"],
[54.9027743667, 82.4772973, "82"],
[54.9113692333, 82.4732625, "242"],
[54.906182, 82.4761095667, "140"],
[54.9126536833, 82.4718492, "283"],
[54.89984655, 82.47884775, "50"],
[54.8996625, 82.4783593833, "51"],
[54.9096838, 82.4734820333, "237"],
[54.9163971333, 82.4703382333, "319"],
[54.9019659333, 82.47801565, "74C"],
[54.9017677, 82.4778972667, "74A"],
[54.9082934833, 82.4747193, "198"],
[54.9124935167, 82.4721662833, "279"],
[54.9112822667, 82.4727057, "263"],
[54.9088314833, 82.4744561333, "220"],
[54.9140193667, 82.4723065, "294A"],
[54.9151048833, 82.4715047667, "302"],
[54.9155721667, 82.4712705333, "308"],
[54.91564375, 82.4698925833, "309"],
[54.9157315333, 82.4712060333, "310"],
[54.9158956833, 82.4711298667, "312"],
[54.9044821667, 82.4765082167, "100"],
[54.9045073333, 82.4759204333, "101"],
[54.9046759167, 82.4758561667, "103"],
[54.8983034667, 82.4792230333, "35"],
[54.8987899833, 82.4796567167, "36"],
[54.89867985, 82.4790447, "39"],
[54.8990768667, 82.47943105, "40"],
[54.8981085333, 82.4793068333, "33"],
[54.89915065, 82.4781128333, "45A"],
[54.8995490167, 82.4791011167, "46"],
[54.8997315333, 82.47899365, "48"],
[54.900319, 82.4785061, "56"],
[54.9056642333, 82.4759370167, "118"],
[54.9063413, 82.4756213333, "150"],
[54.8988354833, 82.47962055, "36A"],
[54.9029526, 82.4760132333, "87"],
[54.90312265, 82.4771544, "86"],
[54.9034438667, 82.4764194333, "91"],
[54.91418395, 82.4719746167, "296"],
[54.9140091667, 82.4714322, "295"],
[54.9141795833, 82.4713487, "297"],
[54.9138469333, 82.4720815833, "292"],
[54.91351575, 82.4716747833, "289"],
[54.9136813667, 82.4716021833, "291"],
[54.9139259667, 82.4722800333, "292A"],
[54.9136332, 82.4722156, "290"],
[54.9093265, 82.4742351667, "224"],
[54.8977406167, 82.4806423167, "24"],
[54.9048411167, 82.4757695667, "109"],
[54.9032051, 82.4765243833, "89"],
[54.91528, 82.4714141667, "304"],
[54.9032850667, 82.4770679, "88"],
[54.9158238167, 82.4703065333, "313A"],
[54.9064744333, 82.4758051, "150A"],
[54.9046115, 82.4767234667, "100A"],
[54.9076618833, 82.4744580667, "197"],
[54.9076246167, 82.4750397167, "190"],
[54.9026504333, 82.4768196167, "79B"],
[54.9051801167, 82.4756040167, "115"],
[54.89852955, 82.47974005, "34"],
[54.9075004, 82.47452445, "187"],
[54.90501535, 82.4756865333, "111"],
[54.9068534667, 82.4753966333, "180"],
[54.9029671, 82.4766338333, "85"],
[54.9065173667, 82.4755659333, "158"],
[54.9066938833, 82.4754834833, "166"],
[54.9061558333, 82.4757093333, "142"],
[54.90567525, 82.4753235167, "119"],
[54.9124889333, 82.4727737833, "278"]
];

================================================
FILE: config.main.json
================================================
{
    "host": null,
    "port": 3000,

    "defaultSkin": "dark",
    "defaultLang": "ru",

    "trafficLayerMinZoom": 10,
    "trafficLayerUpdateInterval": 300000,
    "ppLink2gis": "{gislink}/directions/tab/{rsType}/points/|{point}?m={center}%2F{zoom}&routeLink=true",
    "openLink2gis": "{gislink}/?m={center}%2F{zoom}&openLink=true",
    "ppnotLink": "http://2gis.{domain}/{projectCode}/center/{center}/zoom/{zoom}/routeTab/rsType/{rsType}/to/{point}╎{name}",
    "photosLink": "http://2gis.{domain}/photos/{id}",

    "poiLayerMinZoom": 0,

    "detectRetina": false,

    "webApiKey": "ruregt3044",
    "webApiVersion": "2.0",
    "catalogVersion": "3.0",

    "regionListFields": "items.bounds,items.zoom_level,items.time_zone,items.code,items.flags,items.country_code,items.domain,items.default_pos",
    "firmInfoFields": "items.reviews,items.links,items.external_content",
    "geoAdditionalFields": "items.geometry.selection,items.links,items.adm_div,items.address,items.floors,items.description",
    "geoclickerCatalogApiKey": "ruregt3044",
    "projectLeaveMaxZoom": 16,
    "flampUrl": "http://flamp.ru/r/",
    "flampGoogleAnalytics": "utm_source=api2gis&utm_medium=api&utm_campaign=geoclicker",

    "protocol": "http:",
    "secureProtocol": "https:",

    "baseUrl": "//maps.api.2gis.ru/2.0",
    "key": "c5e4d7ec-f9d0-470f-b7f0-278f622f20e2",

    "keyServer": "https://keys.api.2gis.com/public/v1/keys/",
    "keyServices": "/services/tiles-raster-api",

    "tileServer": "//tile{s}-sdk.maps.2gis.com/v2/tiles?x={x}&y={y}&z={z}&v=1&ts=online_sd&key={key}",
    "retinaTileServer": "//tile{s}-sdk.maps.2gis.com/v2/tiles?x={x}&y={y}&z={z}&v=1&ts=online_hd&key={key}",
    "previewTileServer": "//tile{s}-sdk.maps.2gis.com/v2/tiles?x={x}&y={y}&z={z}&v=1&size=64&ts=online_sd&key={key}",
    "previewRetinaTileServer": "//tile{s}-sdk.maps.2gis.com/v2/tiles?x={x}&y={y}&z={z}&v=1&size=64&ts=online_hd&key={key}",

    "arabicTileServer": "//tile{s}-sdk.maps.2gis.com/v2/tiles?x={x}&y={y}&z={z}&v=1&ts=online_sd_ar&key={key}",
    "arabicRetinaTileServer": "//tile{s}-sdk.maps.2gis.com/v2/tiles?x={x}&y={y}&z={z}&v=1&ts=online_hd_ar&key={key}",
    "arabicPreviewTileServer": "//tile{s}-sdk.maps.2gis.com/v2/tiles?x={x}&y={y}&z={z}&v=1&size=64&ts=online_sd_ar&key={key}",
    "arabicPreviewRetinaTileServer": "//tile{s}-sdk.maps.2gis.com/v2/tiles?x={x}&y={y}&z={z}&v=1&size=64&ts=online_hd_ar&key={key}",

    "trafficTileServer": "//traffic{s}.maps.2gis.com/{projectCode}/traffic/{z}/{x}/{y}/speed/{period}/{timestampString}",
    "retinaTrafficTileServer": "//traffic{s}.maps.2gis.com/{projectCode}/traffic/{z}/{x}/{y}/speed/{period}/retina/{timestampString}",
    "trafficMetaServer": "//meta{s}.maps.2gis.com/{projectCode}/meta/{z}/{x}/{y}/graph_speed/{period}/{timestampString}",
    "retinaTrafficMetaServer": "//meta{s}.maps.2gis.com/{projectCode}/meta/{z}/{x}/{y}/graph_speed/{period}/retina/{timestampString}",
    "trafficTimestampServer": "//traffic{s}.maps.2gis.com/{projectCode}/meta/speed/time/",
    "trafficScoreServer": "//traffic{s}.maps.2gis.com/{projectCode}/meta/score/0/",

    "poiMetaServer": "//tile{s}.maps.2gis.com/poi?x={x}&y={y}&z={z}&v=1&ts=online_sd",
    "retinaPoiMetaServer": "//tile{s}.maps.2gis.com/poi?x={x}&y={y}&z={z}&v=1&ts=online_hd",

    "arabicPoiMetaServer": "//tile{s}.maps.2gis.com/poi?x={x}&y={y}&z={z}&v=1&ts=online_sd_ar",
    "arabicRetinaPoiMetaServer": "//tile{s}.maps.2gis.com/poi?x={x}&y={y}&z={z}&v=1&ts=online_hd_ar",

    "webApiServer": "//catalog.api.2gis.ru",

    "loadProjectListTimeout": 5000
}


================================================
FILE: functional-tests/.gitignore
================================================
## Project ###
nosetests.xml
nosetests-*.xml
run_my.sh
.noseids

### Python ###
*.py[cod]

### Virtualenv ###
.env/

### Tox ###
.tox/

### IDE ###
.idea/

================================================
FILE: functional-tests/README.md
================================================
### Подготовка и запуск

1. Устанавливаем python
2. Устанавливаем virtualenv
   
```
$ pip install -U virtualenv
```
    
3. Готовим локальный environment
    
```
$ ./prepare.sh
```

Если используется PyCharm удобно добавить локальный env.
File -> Settings -> Project -> Шестеренка -> Добавить локальный env -> выбрать ./.env/bin/python2.7

4. Устанавливаем [selenium-launchers](https://github.com/bayandin/selenium-launchers):

```bash
# скачать zip-архив и распаковать куда-нибудь на свою машину
cd selenium-launchers/
./start_linux.sh (./start_mac.sh | ./start_win.sh) # запустит selenuim-сервер на порту 4455
```

5. Тесты используют шаблоны страниц. Для их генерации нужно выполнить:

```
$ ./template_render.sh
```

6. Если не поднят, поднять сервер MapsAPI

7. Запустить тесты

```
$ ./run.sh
```

Чтобы запускать только конкретные тесты, необходимо скопировать файл run.sh в run_my.sh и добавить файл,
класс и метод теста, например:

```bash
#!/usr/bin/env bash
source .env/bin/activate
PYTHONPATH=$(pwd) .env/bin/lode_runner -v tests/firm_callout_test.py:FirmCallout.firm_photo_test --with-xunit
exit 0;
```

### Содержимое проекта

* В пакете classes хранятся компоненты (сomponents), исключения (exceptions), утилиты (util)
* В пакете config хранится конфиг для contesto
* В пакете tests хранятся тесты и пакеты тестов


#### Исключения
Бывает необходимо поднять и обработать исключение.
Все типы исключений для карты, взаимодействия с WebApi и т.д. описываются в classes.exceptioins.exceptions.
Наследуются от базового типа исключений contesto, а затем от базового типа исключения API карт.


#### Утилиты
В данном пакете описываются утилиты и базовые классы тестов для API карт.
На данный момент там содержится базовый класс для тестов MapsAPIBaseTest унаследованный от
UnittestContestoTestCase, с переопределенным методом setUp.


#### Компоненты
В данном пакете описываются компоненты страницы, страница и базовой компонент.
Базовый компонент наследуется от класса BaseComponent contesto. В нем определяются черты (свойства и методы)
свойственные всем компонентам проекта.

### Code style
* Так как используется паттерн pageObject, в тестах не должно быть обращения к драйверу, за исключением пользовательских элементов (кнопки, ползунки и все что не входит в API карт)
* Для проверки кода перед коммитом рекомендуется создать или добавить в pre-commit git hook содержимое pep8-hook.sh. Для работы хука должен иметься pep8. 
* Имена файлов с тестами `<название>_test.py`
* Имена классов оформляются в `CapitalizedWords`
* Имена тестовых методов `<объект тестирования>_<что тестируется>_test(self, *args, **kwargs)`
* Допускается использование нескольких assert`ов в тесте если они связаны с тестируемым функционалом
* Использовать только assert`ы contesto


================================================
FILE: functional-tests/classes/WAPI/__init__.py
================================================


================================================
FILE: functional-tests/classes/WAPI/dataWorker.py
================================================
# -*- coding: utf-8 -*-
from classes.WAPI.request import *
import itertools
# TODO: Сделать хэлпер для выпиливания html entities из ответа API


class GeoData(object):
    def __init__(self, cords, zoom):
        request = GeoSearch()
        self.response = request.get(cords, zoom)

    def get_value_by_key(self, key_name, key_value, key_return):
        """
        :param key_name: Key name, that want use (example: 'subtype')
        :param key_value: Value that element with key_name should be equal (example: 'city')
        :param key_return: Key name that should be returned (example: 'name')
        :return: string or list (depends on field)
        """
        for elem in self.response['items']:
            if elem.get(key_name) == key_value:
                return elem.get(key_return)

    @property
    def city_name(self):
        return self.get_value_by_key('subtype', 'city', 'name')

    @property
    def district_name(self):
        return self.get_value_by_key('subtype', 'district', 'name')

    @property
    def place_address(self):
        adm_divs = self.get_value_by_key('subtype', 'district', 'adm_div')
        adm_divs.reverse()
        dist_addr = adm_divs.pop(0)['name']
        for div in adm_divs:
            dist_addr = "%s, %s" % (dist_addr, div['name'])
        return dist_addr.replace(u'\xa0', ' ')

    @property
    def build_name(self):
        address_name = self.get_value_by_key('subtype', None, 'address_name')
        building_name = self.get_value_by_key('subtype', None, 'building_name')
        if building_name is None:
            return address_name
        else:
            return building_name

    @property
    def street_name(self):
        return self.get_value_by_key('type', 'street', 'name').replace(u'\xa0', ' ')

    @property
    def street_address(self):
        return self.get_value_by_key('type', 'street', 'adm_div')[0]['name'].replace(u'\xa0', ' ')

    @property
    def attraction_name(self):
        subtype_name = self.get_value_by_key('type', 'attraction', 'subtype_name')
        name = self.get_value_by_key('type', 'attraction', 'name')
        if not name:
            return subtype_name
        else:
            return name

    @property
    def attraction_description(self):
        return self.get_value_by_key('type', 'attraction', 'description')


class FirmData(object):
    def __init__(self, firm_id):
        request = FirmInfo()
        self.response = request.get(firm_id)

    @property
    def firm_name(self):
        return self.response['items'][0]['name']

    @property
    def review_count(self):
        return self.response['items'][0]['reviews']['review_count']

    @property
    def rating(self):
        return self.response['items'][0]['reviews']['rating']

    @property
    def address_name(self):
        return self.response['items'][0]['address_name'].replace(u'\xa0', ' ')

    @property
    def address_comment(self):
        return self.response['items'][0]['address_comment'].replace(u'\xa0', ' ')

    def _contacts_by_type(self, contact_type):
        contacts = list()
        contact_groups = self.response['items'][0]['contact_groups']
        for group in contact_groups:
            for item in group['contacts']:
                if item['type'] == contact_type:
                    contacts.append(item)
        return contacts

    def get_phones(self):
        return self._contacts_by_type('phone')

    def get_websites(self):
        return self._contacts_by_type('website')

    def get_emails(self):
        return self._contacts_by_type('email')

    def get_rubrics_primary(self):
        primary = list()
        rubrics = self.response['items'][0]['rubrics']
        for rubric in rubrics:
            if rubric['kind'] == 'primary':
                primary.append(rubric)
        return primary

    def get_rubrics_additional(self):
        additional = list()
        rubrics = self.response['items'][0]['rubrics']
        for rubric in rubrics:
            if rubric['kind'] == 'additional':
                additional.append(rubric)
        return additional

    def photo_count(self):
        try:
            externals = self.response['items'][0]['external_content']
            for item in externals:
                if item['subtype'] == 'common':
                    return item['count']
        except KeyError:
            return 0


class GalleryData(object):
    def __init__(self, gallery_id):
        request = GalleryInfo()
        self.response = request.get(gallery_id)

    @property
    def gallery_name(self):
        return self.response['items'][0]['name']


================================================
FILE: functional-tests/classes/WAPI/request.py
================================================
# -*- coding: utf-8 -*-
import urllib2
import urllib
import json
from config import config
from classes.exceptions.exceptions import WebAPIException


class BaseReq(object):

    def __init__(self):
        self.api_url = '%s/%s' % (config.wapi['url'], config.wapi['version'])
        self.base_params = {
            'key': config.wapi['key']
        }

    def request(self, url, params):
        """
        :type url: str or unicode
        :type params: dict
        :rtype: dict
        """
        data = urllib.urlencode(params)
        req = urllib2.Request('%s?%s' % (url, data))  # GET-method
        response = urllib2.urlopen(req).read()
        try:
            result = json.loads(response)
        except ValueError:
            raise WebAPIException('Response not in json')
        else:
            if not result['meta']['code'] == 200 and not result['meta']['code'] == 404:
                raise WebAPIException('Response code is %s, API response:\n%s' % (result['meta']['code'], result))
            return result['result']


class GeoSearch(BaseReq):
    def __init__(self):
        super(GeoSearch, self).__init__()

    def get(self, coord, zoom):
        """
        :param coord: diсt of lat and lng
        :param zoom:  int or str
        :return: dict
        """
        method = '/geo/search'
        params = {
            'key': self.base_params['key'],
            'point': '%s,%s' % (coord['lng'], coord['lat']),
            'zoom_level': str(zoom),
            'fields': 'items.geometry.selection,items.links,items.adm_div,items.address,items.floors,items.description',
            'type': 'adm_div.settlement,adm_div.city,adm_div.division,adm_div.district,'
                    'street,building,adm_div.place,poi,attraction'
        }
        url = self.api_url + method
        return self.request(url, params)


class FirmList(BaseReq):
    def __init__(self):
        super(FirmList, self).__init__()

    def get(self, build_id, page=1):
        """
        :param build_id: int or str
        :param page:  int or str
        :return: dict
        """
        method = '/catalog/branch/list'
        params = {
            'key': self.base_params['key'],
            'building_id': str(build_id),
            'page': str(page)
        }
        url = "%s%s" % (self.api_url, method)
        return self.request(url, params)


class FirmInfo(BaseReq):
    def __init__(self):
        super(FirmInfo, self).__init__()

    def get(self, firm_id):
        """
        :param firm_id: int or str
        :return: dict
        """
        method = '/catalog/branch/get'
        params = {
            'key': self.base_params['key'],
            'id': str(firm_id),
            'type': 'filial',
            'fields': 'items.reviews,items.links,items.external_content'
        }
        url = "%s%s" % (self.api_url, method)
        return self.request(url, params)


class GalleryInfo(BaseReq):
    def __init__(self):
        super(GalleryInfo, self).__init__()

    def get(self, id):
        """
        :param id: int or str
        :return: dict
        """
        method = '/geo/get'
        params = {
            'key': self.base_params['key'],
            'id': str(id),
            'type': 'filial',
            'fields': 'items.geometry.selection,items.links,items.adm_div,items.address,items.floors,items.description'
        }
        url = "%s%s" % (self.api_url, method)
        return self.request(url, params)


================================================
FILE: functional-tests/classes/__init__.py
================================================


================================================
FILE: functional-tests/classes/components/__init__.py
================================================


================================================
FILE: functional-tests/classes/components/balloon.py
================================================
# -*- coding: utf-8 -*-
from classes.components.component import Component
from config import config
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from time import time
from contesto.exceptions import ElementNotFound
from time import sleep
from classes.util.decorators import catches_not_found


class Balloon(Component):
    selectors = {
        'self': '.leaflet-popup',
        'content': '.dg-popup__container',
        'scroll': '.dg-scroller__bar'
    }

    def wait_present(self):
        WebDriverWait(self.driver, config.timeout['normal']).until(
            EC.visibility_of(self.driver.find_element(By.CSS_SELECTOR, self.selectors['self']))
        )

    def wait_close(self, timeout=0.5, polling=0.1):
        start = time()
        end = start + timeout
        present = True
        step = start + polling
        while time() < end and present:
            if time() > step:
                step += polling
                try:
                    self.driver.find_element_by_css_selector(['self'])
                except ElementNotFound:
                    present = False
            else:
                sleep(polling)

    def count(self):
        return len(self.driver.find_elements_by_css_selector(self.selectors['self']))

    def get_content(self):
        return self.driver.find_element_by_css_selector(self.selectors['content'])

    @property
    def width(self):
        return self.driver.find_element_by_css_selector(self.selectors['self']).value_of_css_property('width')

    @property
    def height(self):
        return self.driver.find_element_by_css_selector(self.selectors['self']).value_of_css_property('height')

    @property
    @catches_not_found()
    def scroll(self):
        return self.driver.find_element_by_css_selector(self.selectors['scroll'])


class BalloonCrossed(Balloon):
    selectors = {
        'self': '.leaflet-popup',
        'header': '.dg-popup__header-title',
        'X': '.leaflet-popup-close-button'
    }

    def close(self):
        self.element.find_element_by_css_selector(self.selectors['X']).click()


================================================
FILE: functional-tests/classes/components/callout.py
================================================
# -*- coding: utf-8 -*-
from classes.util.unescape import unescape_text
from classes.util.decorators import catches_not_found
from classes.components.balloon import BalloonCrossed


class Callout(BalloonCrossed):
    pass


class UnknownPlace(Callout):
    """
    Unknown place callout
    """
    selectors = {
        'self': '.leaflet-popup',
        'header': '.dg-popup__header-title',
        'X': '.leaflet-popup-close-button'
    }

    @property
    def header(self):
        """
        :return: str
        """
        return self.element.find_element_by_css_selector(self.selectors['header']).text.strip()


class Place(Callout):
    """
    Base place callout (example: city callout)
    """
    selectors = {
        'self': '.leaflet-popup',
        'header': '.dg-popup__header-title',
        'X': '.leaflet-popup-close-button',
        'purpose': '.dg-map-geoclicker__purpose'
    }

    @property
    def header(self):
        """
        :return: str
        """
        return self.element.find_element_by_css_selector(self.selectors['header']).text.strip()

    @property
    def purpose(self):
        """
        :return: str
        """
        return self.element.find_element_by_css_selector(self.selectors['purpose']).text.strip()


class AddressPlace(Place):
    """
    Addressed place callout (example: district)
    """
    selectors = {
        'self': '.leaflet-popup',
        'header': '.dg-popup__header-title',
        'X': '.leaflet-popup-close-button',
        'purpose': '.dg-map-geoclicker__purpose',
        'drilldown': '.dg-map-geoclicker__drilldown'
    }

    @property
    def drilldown(self):
        """
        :return: str
        """
        return unescape_text(self.element.find_element_by_css_selector(self.selectors['drilldown']).text.strip())


class Attraction(Callout):
    """
    Attraction callout without text (example: sandboxes, toilets, attractions)
    """
    selectors = {
        'self': '.leaflet-popup',
        'header': '.dg-popup__header-title',
        'X': '.leaflet-popup-close-button',
        'purpose': '.dg-map-geoclicker__purpose'
    }

    @property
    def header(self):
        """
        :return: str
        """
        return self.element.find_element_by_css_selector(self.selectors['header']).text.strip()

    @property
    def purpose(self):
        """
        :return: str
        """
        return self.element.find_element_by_css_selector(self.selectors['purpose']).text.strip()


class AttractionWrapped(Attraction):
    """
    Attraction callout with text (example: monuments etc.)
    """
    selectors = {
        'self': '.leaflet-popup',
        'header': '.dg-popup__header-title',
        'X': '.leaflet-popup-close-button',
        'purpose': '.dg-map-geoclicker__purpose',
        'wrapper': '.dg-map-geoclicker__show-more-sights-link',
        'text': '.dg-map-geoclicker__sight-description'
    }

    @property
    def text(self):
        """
        :return: str
        """
        return self.element.find_element_by_css_selector(self.selectors['text']).text.strip()

    @catches_not_found(False)
    def wrapper(self):
        return self.element.find_element_by_css_selector(self.selectors['wrapper'])

    def unwrap(self):
        self.element.find_element_by_css_selector(self.selectors['wrapper']).click()


class Build(Callout):
    """
    Base build callout
    """
    selectors = {
        'self': '.leaflet-popup',
        'header': '.dg-popup__header-title',
        'X': '.leaflet-popup-close-button',
        'firm': '.dg-popup__link',
        'firm_list': '.dg-popup__button_name_all'
    }
    # TODO добавить конструктор route-ссылок

    @property
    def header(self):
        """
        :return: str
        """
        return self.element.find_element_by_css_selector(self.selectors['header']).text.strip()

    def open_firm_by_index(self, index):
        self.driver.find_elements_by_css_selector(self.selectors['firm'])[index].click()

    @catches_not_found()
    def open_firm_list(self):
        self.driver.find_element_by_css_selector(self.selectors['firm_list']).click()

    @catches_not_found()
    def open_firm_by_id(self, firm_id):
        self.driver.find_element_by_id(str(firm_id)).click()


class FirmList(Callout):
    """
    Firm list callout
    """
    selectors = {
        'self': '.leaflet-popup',
        'header': '.dg-popup__header-title',
        'X': '.leaflet-popup-close-button',
        'list': '.dg-building-callout__list'
    }

    def list_present(self):
        return self.driver.find_element_by_css_selector(self.selectors['list']).is_displayed()


class Firm(Callout):
    """
    Firm and common poi callout
    """
    selectors = {
        'self': '.leaflet-popup',
        'header': '.dg-popup__header-title',
        'X': '.leaflet-popup-close-button',
        'photo': '.dg-popup__link_type_photos',
        'reviews': '.dg-popup__link_type_flamp_reviews',
        'stars': '.dg-popup__rating-stars',
        'back': '.dg-popup__button_name_firm-card-back',
        'route': '.dg-popup__button_name_goto',
        'address': '.dg-firm-card__address',
        'phones': '.dg-firm-card__phone-num',
        'websites': '.dg-firm-card__site',
        'email': '.dg-firm-card__email > a',
        'primary': '.dg-firm-card__rubrics-list_type_primary > .dg-firm-card__rubrics-list-item',
        'additional': '.dg-firm-card__rubrics-list_type_additional > .dg-firm-card__rubrics-list-item'
    }

    @property
    def callout(self):
        return self.driver.find_element_by_css_selector(self.selectors['self'])

    @property
    def header(self):
        """
        :return: str
        """
        return self.element.find_element_by_css_selector(self.selectors['header']).text.strip()

    @property
    @catches_not_found()
    def photo(self):
        """
        :return: web_element
        """
        return self.element.find_element_by_css_selector(self.selectors['photo'])

    @property
    @catches_not_found()
    def reviews(self):
        """
        :return: web_element
        """
        return self.element.find_element_by_css_selector(self.selectors['reviews'])

    @property
    @catches_not_found()
    def stars(self):
        """
        :return: web_element
        """
        return self.element.find_element_by_css_selector(self.selectors['stars'])

    @catches_not_found()
    def back(self):
        return self.element.find_element_by_css_selector(self.selectors['back']).click()

    @property
    def route_link(self):
        return self.element.find_element_by_css_selector(self.selectors['route'])

    @property
    def address(self):
        return self.driver.find_element_by_css_selector(self.selectors['address'])

    def phones(self):
        return self.driver.find_elements_by_css_selector(self.selectors['phones'])

    def websites(self):
        return self.driver.find_elements_by_css_selector(self.selectors['websites'])

    @property
    def email(self):
        return self.driver.find_element_by_css_selector(self.selectors['email'])

    @property
    def primary_rubrics(self):
        return self.driver.find_elements_by_css_selector(self.selectors['primary'])

    @property
    def additional_rubrics(self):
        return self.driver.find_elements_by_css_selector(self.selectors['additional'])


================================================
FILE: functional-tests/classes/components/component.py
================================================
from contesto.basis.component import BaseComponent
from selenium.webdriver.common.action_chains import ActionChains


class Component(BaseComponent):
    def __init__(self, test, element):
        """
        :type test: InfoPortalDriver
        :type element: InfoPortalWebElement
        """
        super(Component, self).__init__(test, element)
        self.test = self.driver

    def hover(self):
        ActionChains(self.driver).move_to_element(self.element).perform()

    @property
    def is_visible(self):
        return self.element.is_displayed()


================================================
FILE: functional-tests/classes/components/map.py
================================================
# -*- coding: utf-8 -*-
from selenium.webdriver import ActionChains
from selenium.webdriver.common.keys import Keys
from component import Component
from classes.util.scripts import GetScripts
from classes.util.scripts import SetScripts
from time import time
import math
from time import sleep


class Map(Component):
    selectors = {
        'self': '#map',
        'info': '#info'
    }

    def zoom_selection(self):
        center = self.driver.execute_script(GetScripts.getContainerCenter)
        actions = ActionChains(self.driver)
        actions.move_to_element_with_offset(self.element, int(center['x']), int(center['y']))
        actions.key_down(Keys.SHIFT)
        actions.click_and_hold()
        actions.move_by_offset(300, 300)
        actions.release()
        actions.perform()

    def center_click(self):
        center = self.driver.execute_script(GetScripts.getContainerCenter)
        actions = ActionChains(self.driver)
        actions.move_to_element_with_offset(self.element, int(center['x']), int(center['y']))
        actions.click().perform()

    def center_dbclick(self):
        center = self.driver.execute_script(GetScripts.getContainerCenter)
        actions = ActionChains(self.driver)
        actions.move_to_element_with_offset(self.element, int(center['x']), int(center['y']))
        actions.double_click().perform()

    def set_zoom(self, level):
        self.driver.execute_script(SetScripts.set_zoom(level))

    def wait_init(self, timeout=3, polling=0.5):
        """
        :param timeout: timeout to rise exception
        :param polling: how often check map init
        :return: None
        """
        request_num = math.ceil(timeout / polling)
        tries = 0
        tries_out = False
        map_inited = False
        start = time()
        while not tries_out and not map_inited:
            if time() > (start + tries * polling):
                map_inited = self.driver.execute_script('return !!map.getZoom')
                tries_out = tries >= request_num
                tries += 1

    def drag(self, x_offset, y_offset):
        center = self.driver.execute_script(GetScripts.getContainerCenter)
        actions = ActionChains(self.driver)
        actions.move_to_element_with_offset(self.element, int(center['x']), int(center['y']))
        actions.click_and_hold()
        actions.move_by_offset(x_offset, y_offset)
        actions.release().perform()

    def info_elem(self):
        return self.driver.find_element_by_css_selector(self.selectors['info'])


================================================
FILE: functional-tests/classes/components/mapsapi_sources.py
================================================
from component import Component
from classes.util.decorators import catches_not_found


class Source(Component):
    selectors = {
        'loader': '[src*="loader"]',
        'app_js': 'script[src*="/js/?"]'
    }

    @property
    @catches_not_found(False)
    def loader_present(self):
        return bool(self.driver.find_element_by_css_selector(self.selectors['loader']))

    @property
    @catches_not_found(False)
    def app_js_present(self):
        return bool(self.driver.find_element_by_css_selector(self.selectors['app_js']))


================================================
FILE: functional-tests/classes/components/marker.py
================================================
from classes.components.component import Component
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.action_chains import ActionChains
from config import config


class Marker(Component):
    selectors = {
        'self': 'div.leaflet-pane.leaflet-marker-pane > div.dg-customization__marker',
        'label': 'div.dg-label > div.dg-label__content'
    }

    def click(self, index=0):
        self.driver.find_elements_by_css_selector(self.selectors['self'])[index].click()

    def wait_present(self):
        WebDriverWait(self.driver, config.timeout['normal']).until(
            EC.visibility_of(self.driver.find_element(By.CSS_SELECTOR, self.selectors['self']))
        )

    def drag_marker(self, x_offset, y_offset, index=0):
        actions = ActionChains(self.driver)
        marker = self.driver.find_elements_by_css_selector(self.selectors['self'])[index]
        actions.drag_and_drop_by_offset(marker, x_offset, y_offset).perform()

    def get_lat(self, name='marker'):
        return self.driver.execute_script('return %s._latlng.lat.toFixed(3)' % name)

    def get_lng(self, name='marker'):
        return self.driver.execute_script('return %s._latlng.lng.toFixed(3)' % name)

    def get_labels(self):
        return self.driver.find_elements_by_css_selector(self.selectors['label'])

    def get_markers(self):
        return self.driver.find_elements_by_css_selector(self.selectors['self'])

    def hover_marker(self, index=0):
        actions = ActionChains(self.driver)
        actions.move_to_element(self.get_markers()[index]).perform()

    def count(self):
        return len(self.driver.find_elements_by_css_selector(self.selectors['self']))


================================================
FILE: functional-tests/classes/components/page.py
================================================
from contesto.basis.page import BasePage
from time import sleep


class Page(BasePage):
    def __init__(self, test):
        """
        :type test: Mapsapi driver
        """
        self.test = test
        super(Page, self).__init__(test)

    def refresh(self):
        super(Page, self).refresh()
        self.__init__(self.test)

    def forward(self):
        super(Page, self).forward()
        self.__init__(self.test)

    def back(self):
        super(Page, self).back()
        self.__init__(self.test)

    @property
    def new_window_url(self):
        win_count = len(self.test.window_handles)
        self.test.switch_to_window(self.test.window_handles[win_count - 1])
        return self.test.current_url

    def click(self):
        """
        Left-clicks the current cursor position
        """
        from selenium.webdriver.common.action_chains import ActionChains
        act = ActionChains(self.test)
        act.click().perform()

    @property
    def map(self):
        """
        :return: MapContainer
        """
        from classes.components.map import Map
        return Map(self.test, self.test.find_element_by_css_selector(Map.selectors['self']))

    @property
    def zoom_control_in(self):
        """
        :rtype: ZoomControlIn
        """
        from classes.components.zoom_control import ZoomControlIn
        return ZoomControlIn(self.test, self.test.find_element_by_css_selector(ZoomControlIn.selectors['self']))

    @property
    def zoom_control_out(self):
        """
        :rtype: ZoomControlOut
        """
        from classes.components.zoom_control import ZoomControlOut
        return ZoomControlOut(self.test, self.test.find_element_by_css_selector(ZoomControlOut.selectors['self']))

    @property
    def balloon(self):
        """
        :return: Callout
        """
        from classes.components.balloon import Balloon
        return Balloon(self.test, self.test.find_element_by_css_selector(Balloon.selectors['self']))

    @property
    def balloon_crossed(self):
        """
        :return: CalloutCrossed
        """
        from classes.components.callout import BalloonCrossed
        return BalloonCrossed(self.test, self.test.find_element_by_css_selector(BalloonCrossed.selectors['self']))

    @property
    def unkown_place(self):
        """
        :return: UnknownPlace
        """
        from classes.components.callout import UnknownPlace
        return UnknownPlace(self.test, self.test.find_element_by_css_selector(UnknownPlace.selectors['self']))

    @property
    def place_callout(self):
        """
        :return: PlaceCallout
        """
        from classes.components.callout import Place
        return Place(self.test, self.test.find_element_by_css_selector(Place.selectors['self']))

    @property
    def addresed_place_callout(self):
        """
        :return: AddressPlaceCallout
        """
        from classes.components.callout import AddressPlace
        return AddressPlace(self.test, self.test.find_element_by_css_selector(AddressPlace.selectors['self']))

    @property
    def build_callout(self):
        """
        :return: BuildCallout
        """
        from classes.components.callout import Build
        return Build(self.test, self.test.find_element_by_css_selector(Build.selectors['self']))

    @property
    def attraction_callout(self):
        """
        :return: AttractionCallout
        """
        from classes.components.callout import Attraction
        return Attraction(self.test, self.test.find_element_by_css_selector(Attraction.selectors['self']))

    @property
    def attraction_callout_wrapped(self):
        """
        :return: AttractionCallout
        """
        from classes.components.callout import AttractionWrapped
        return AttractionWrapped(self.test, self.test.find_element_by_css_selector(AttractionWrapped.selectors['self']))

    @property
    def firm_callout(self):
        """
        :return: FirmCallout
        """
        from classes.components.callout import Firm
        return Firm(self.test, self.test.find_element_by_css_selector(Firm.selectors['self']))

    @property
    def marker(self):
        """
        :return: Marker
        """
        from classes.components.marker import Marker
        return Marker(self.test, self.test.find_element_by_css_selector(Marker.selectors['self']))

    def console(self, script, timeout=0):
        result = self.test.execute_script(script)
        sleep(timeout)
        return result

    @property
    def firm_list(self):
        """
        :return: FirmList callout
        """
        from classes.components.callout import FirmList
        return FirmList(self.test, self.test.find_element_by_css_selector(FirmList.selectors['self']))

    @property
    def sources(self):
        """
        :return: Source
        """
        from classes.components.mapsapi_sources import Source
        return Source(self.test, self.test.find_element_by_css_selector(Source.selectors['loader']))


================================================
FILE: functional-tests/classes/components/zoom_control.py
================================================
# -*- coding: utf-8 -*-
from component import Component


class ZoomControlIn(Component):
    selectors = {
        'self': '.dg-zoom__in > div'
    }

    def zoom_in_click(self):
        self.element.click()


class ZoomControlOut(Component):
    selectors = {
        'self': '.dg-zoom__out > div'
    }

    def zoom_out_click(self):
        self.element.click()


================================================
FILE: functional-tests/classes/exceptions/__init__.py
================================================



================================================
FILE: functional-tests/classes/exceptions/exceptions.py
================================================
from contesto.exceptions import BaseError


class MapsApiException(BaseError):
    pass


class ElementNotFoundException(MapsApiException):
    pass


class UnknownElementException(MapsApiException):
    pass


class WebAPIException(MapsApiException):
    pass


class CommonException(MapsApiException):
    pass


class NoPageIsSelected(MapsApiException):
    pass


class NotTransportTypeError(MapsApiException):
    pass


class NotGeoTypeError(MapsApiException):
    pass


class NotFirmTypeError(MapsApiException):
    pass


================================================
FILE: functional-tests/classes/mapsapi_base_test.py
================================================
# -*- coding: utf-8 -*-
from classes.components.page import Page
from contesto.basis.test_case import UnittestContestoTestCase
from config import config


# TODO: Переопределить логгер из contesto, чтоб не падать при пустых логах
class MapsAPIBaseTest(UnittestContestoTestCase):
    def setUp(self):
        super(MapsAPIBaseTest, self).setUp()
        self.page = Page(self.driver)
        if self.driver.browser != 'opera' or self.driver.browser != 'phantomjs':
            self.driver.maximize_window()
        self.driver.set_script_timeout(config.timeout["normal"])
        self._webAPI = None
        self._baseWAPI = None

    def tearDown(self):
        # log.info("JS Errors: %s" % self.driver.js_errors)
        super(MapsAPIBaseTest, self).tearDown()


================================================
FILE: functional-tests/classes/util/__init__.py
================================================
# -*- coding: utf-8 -*-


================================================
FILE: functional-tests/classes/util/decorators.py
================================================
# -*- coding: utf-8 -*-
from contesto import config
from contesto.exceptions import ElementNotFound
from selenium.webdriver.support.wait import WebDriverWait
import functools


def catches_not_found(if_not_found=None):
    def wrapper(f):
        @functools.wraps(f)
        def decorated(self, *args, **kwargs):
            try:
                return f(self, *args, **kwargs)
            except ElementNotFound:
                return if_not_found
        return decorated
    return wrapper


def waits_for(selectors, appear=False):
    def wrap(f):
        def decorate(self, *args, **kwargs):
            f(self, *args, **kwargs)
            for selector in selectors:
                try:
                    driver = self.test if 'test' in self.__class__.__dict__ else self.driver
                    wait = WebDriverWait(driver, float(config.timeout['normal']))
                    if appear:
                        wait.until(lambda dr: dr.find_element_by_css_selector(selector).is_displayed())
                    else:
                        wait.until_not(lambda dr: dr.find_element_by_css_selector(selector).is_displayed())
                except ElementNotFound:
                    continue
        return decorate
    return wrap


def try_x_times(x, exceptions_to_catch, exception_to_raise, fn):
    """
    :param x: int
    :param exceptions_to_catch: tuple of Exception
    :param exception_to_raise: tuple of Exception
    :param fn: function
    """
    @functools.wraps(fn)  # keeps name and docstring of old function
    def new_fn(*args, **kwargs):
        for i in xrange(x):
            try:
                return fn(*args, **kwargs)
            except exceptions_to_catch:
                pass
        raise exception_to_raise
    return new_fn

================================================
FILE: functional-tests/classes/util/geo_types_map.py
================================================
# -*- coding: utf-8 -*-

"""
Взято из models/geo.js
"""

geo_type = {
    'street': u'Улица',
    'house': u'Дом',
    'district': u'Район',
    'division': u'Округ',
    'city': u'Город',
    'settlement': u'Населенный пункт',
    'station': u'Остановка',
    'station_platform': u'Остановочная платформа',
    'living_area': u'Микрорайон',
    'place': u'Место',
    'sight': u'Достопримечательность',
    'crossroad': u'Перекресток',
    'metro': u'Станция метро',
}

================================================
FILE: functional-tests/classes/util/link_generator.py
================================================
def photo_link(firm_id):
    return "http://2gis.ru/photos/%s" % firm_id


def reviews_link(firm_id):
    return "http://flamp.ru/r/%s?utm_source=api2gis&utm_medium=api&utm_campaign=geoclicker" % firm_id


================================================
FILE: functional-tests/classes/util/misc.py
================================================
# -*- coding: utf-8 -*-
import urllib


def extend(extension, base):
    """
    :param base: dict of dicts
    :param extension: dict
    :return: dict
    Extend each base dict from key of extension
    """
    for part in base:
        for default_prop in extension:
            if default_prop not in base[part]:
                base[part][default_prop] = extension[default_prop]
    return base


def comment_equals(comment, wapi_comment):
    """
    :type comment: str or unicode
    :type wapi_comment: str or unicode
    :rtype: bool
    """
    return comment == '— '.decode('utf-8') + wapi_comment


def unicode_print(s):
    """
    Prints unicode strings
    :type s: unicode
    """
    s = to_unicode(s)
    print u'%s' % s,


def to_unicode(s):
    """
    Converts string to unicode if necessary
    :type s: str or unicode
    :rtype: unicode
    """
    try:
        s = str(s)
        return s.decode('utf-8')
    except UnicodeEncodeError:
        return s


def rprint(item):
    """
    Prints list or dict recursively.
    :type item: list, dict
    """
    if isinstance(item, list):
        print '[',
        for i in item:
            rprint(i)
            print ', ',
        print ']',
    elif isinstance(item, dict):
        print '{',
        for key, val in item.iteritems():
            unicode_print(key)
            print ': ',
            rprint(val)
            print ', ',
        print '}',
    else:
        unicode_print(item)


class AttrDict(dict):
    """
    Wraps a dict object or literal to access values like object properties:
    my_dict = AttrDict( {'a': 1} )
    assert my_dict.a == 1
    """
    def __init__(self, *args, **kwargs):
        super(AttrDict, self).__init__(*args, **kwargs)
        self.__dict__ = self


def to_str(s):
    """
    Converts unicode to string if necessary
    :type s: str or unicode
    :rtype: str
    """
    try:
        return s.encode('utf-8')
    except UnicodeDecodeError:
        return s


def to_int(s):
    """
    Return first number from string
    :param s: strin or unicode
    :return: int
    """
    out = ''
    started = False
    for x in s:
        if x.isdigit():
            out += x
            started = True
        if started and not x.isdigit():
            return int(out)
    return int(out)


def address_and_comment(address, comment):
    return u"%s— %s" % (address, comment)


def phone_and_comment(phone, comment):
    return u"%s—  %s" % (phone, comment)


def check_route(link, check_part):
    """
    :param link: string with route link
    :param check_part: list of fixture base parts of route link
    :return: bool
    Remove protocol and unquote url
    Split route link by '/', split last part by '╎', split coordinates part by ','
    Save each parts in 'parts' list with original order.
    Round coordinates and check equal part in parts and check_part, save result in 'check' list
    Return all True of check list.
    """
    # unquote
    link = urllib.unquote(to_str(link[7:]))
    # make parts list
    parts = link.split('/')
    coords = parts[len(parts) - 1].split('╎')[0]
    address = parts[len(parts) - 1].split('╎')[1]
    parts.remove(parts[len(parts) - 1])
    parts.append(coords)
    parts.append(address)
    center = parts[3].split(',')
    baloon = parts[len(parts) - 2].split(',')
    parts[3] = center[0]
    parts.insert(4, center[1])
    parts[len(parts) - 2] = baloon[0]
    parts.insert(len(parts) - 1, baloon[1])
    # check equals
    i = 0
    check = list()
    while i < len(parts):
        if isinstance(check_part[i], float):
            check_part[i] = round(check_part[i], 2)
            parts[i] = round(float(parts[i]), 2)
        check.append(check_part[i] == parts[i])
        i += 1
    return all(item for item in check)


def coord_equals(expected, got, precision):
    """
    :param expected: Expected coordinate value
    :param got: Got coordinate value
    :param precision: Precision for round latitude and longitude
    :return: bool
    Check part by part coordinate equals with precision
    """
    checks = list()
    checks.append(round(expected['lat'], precision) == round(got['lat'], precision))
    checks.append(round(expected['lng'], precision) == round(got['lng'], precision))
    print(round(expected['lat'], precision))
    print(round(got['lat'], precision))
    print(round(expected['lng'], precision))
    print(round(got['lng'], precision))
    return all(check for check in checks)


def coord_string_to_dict(coord_str):
    """
    :param coord_str: string like 'lat, lng'
    :return: dict from coord_string content lat and lng respectively
    """
    parts = coord_str.split(', ')
    return {'lat': float(parts[0]), 'lng': float(parts[1])}


================================================
FILE: functional-tests/classes/util/scripts.py
================================================
class GetScripts:
    getZoom = 'return map.getZoom();'
    getCenter = 'return map.getCenter();'
    getContainerCenter = 'return map.latLngToContainerPoint(map.getCenter());'


class SetScripts:

    @staticmethod
    def set_zoom(level=10):
        return 'map.setZoom(%s, {animate: false});' % str(level)

    @staticmethod
    def pan_to(lat, lng):
        return 'map.panTo([%s, %s], {animate: false});' % (str(lat), str(lng))

    @staticmethod
    def set_lang(lang):
        return 'map.setLang("%s");' % str(lang)

    @staticmethod
    def open_marker(name='marker'):
        return '%s.openPopup();' % name

    @staticmethod
    def dg_then(cb=''):
        return 'DG.then(%s);' % cb


================================================
FILE: functional-tests/classes/util/transport_types_map.py
================================================
# -*- coding: utf-8 -*-

route_type = {
    'bus': u'Автобус',
    'trolleybus': u'Троллейбус',
    'tram': u'Трамвай',
    'shuttle_bus': u'Маршрутное такси',
    'metro': u'Метро',
    'suburban_train': u'Электропоезд',
    'funicular_railway': u'Фуникулер',
    'monorail': u'Монорельс',
    'river_transport': u'Речной транспорт',
    'cable_car': u'Канатная дорога',
    'light_rail': u'Скоростной трамвай',
    'premetro': u'Метротрам',
    'light_metro': u'Лёгкое метро',
}


================================================
FILE: functional-tests/classes/util/unescape.py
================================================
# -*- coding: utf-8 -*-


def unescape_text(text):
    """
    АПИ передает в выдаче эскейп-символы. Метод преобразовывает их в нормальный вид
    см tests/search/firms_minicard/
    """
    import HTMLParser
    return HTMLParser.HTMLParser().unescape(text)


================================================
FILE: functional-tests/config/__init__.py
================================================
import os

import contesto
from contesto import config as cfg

contesto.config.add_config_file(os.path.abspath(os.path.dirname(__file__)) + "/config.ini")
contesto.config.add_config_file(os.path.abspath(os.path.dirname(__file__)) + "/config.my.ini")

config = cfg


================================================
FILE: functional-tests/config/config.ini
================================================
[AUT]
local: http://127.0.0.1:3000/pages


[Selenium]
host: localhost
port: 4455
browser: chrome

[Timeout]
normal: 5

[Session]
shared: 0

[WAPI]
url: http://catalog.api.2gis.ru
key: ruregt3044
version: 2.0


================================================
FILE: functional-tests/config/config.my.ini
================================================
;[AUT]
;local: http://maps.test.webmaps.ostack.test/2.0/pages
;
;
;[Selenium]
;host: vmmaster.auto.ostack.test
;port: 9000
;platform: ubuntu-14.04-x64
;browser: chrome
;user: webmaps
;token: d2cf4ace-b964-4d39-9df7-5b676d35a6b7
;
;[Timeout]
;normal: 10
;loading: 10
;
;[Session]
;shared: 0
;
;[WAPI]
;url: http://catalog.api.2gis.ru
;key: ruregt3044
;version: 2.0


================================================
FILE: functional-tests/pep8
================================================
[pep8]
ignore=E501

================================================
FILE: functional-tests/pep8-hook.sh
================================================
#!/bin/sh

py_files=$(git diff `git merge-base master HEAD`..HEAD --name-only | grep ".py$")
if [ "$py_files" = "" ]; then
    exit 0
fi

pass=true

echo "\nValidating python source files:\n"

for file in ${py_files}; do
    result=$(pep8 --format=pylint --config=functional-tests/pep8 ${file})
    if [ "$result" != "" ]; then
        echo "\t\033[31mpep8 Failed: ${file}\033[0m"
        echo "$result"
        pass=false
    else
        echo "\t\033[32mpep8 Passed: ${file}\033[0m"
    fi
done

echo "\nPython validation complete\n"

if ! $pass; then
    echo "\033[41mCOMMIT FAILED:\033[0m Your commit contains files that should pass pep8 but do not. Please fix the pep8 errors and try again.\n"
    exit 1
else
    echo "\033[42mCOMMIT SUCCEEDED\033[0m\n"
fi


================================================
FILE: functional-tests/prepare.sh
================================================
#!/usr/bin/env bash
virtualenv --python=python .env
source .env/bin/activate
pip install -U git+https://github.com/2gis/contesto.git@53ff11259171a8fca74cbc04bf83bbdec668424d
pip install -U git+https://github.com/2gis/lode_runner.git@7cbd608328058b4c622fcd8795a8804ef121cae7
pip install -U selenium
pip install -U pep8
pip install -U jinja2


================================================
FILE: functional-tests/run.sh
================================================
#!/usr/bin/env bash
source .env/bin/activate
PYTHONPATH=$(pwd) .env/bin/lode_runner -v tests/ --with-xunit
exit 0;


================================================
FILE: functional-tests/template_render.sh
================================================
#!/usr/bin/python
# -*- coding: utf-8 -*-
from jinja2 import Template
from templates.content import pages
import codecs
import os

if not os.path.exists('../dist/pages'):
    os.mkdir('../dist/pages')

base = open('templates/base.html', 'r')
template = Template(base.read())
base.close()

parts = pages()

for page in parts:
    out = codecs.open("../dist/pages/%s.html" % parts[page]['title'], 'w', 'utf-8')
    out.write(template.render(parts[page]))
    out.close()


================================================
FILE: functional-tests/templates/__init__.py
================================================


================================================
FILE: functional-tests/templates/base.html
================================================
<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>{{title}}</title>
        <script src="{{loaderPath}}/loader.js{{getParams}}" {{dgLoader}}></script>
        <style>
            {{headStyle}}
        </style>
    </head>
    <body>
        <span id="info">{{info}}</span>
        <div id="map" style="{{style}}"></div>
        <script>
            {{mapInit}}
        </script>
        {{controls}}
    </body>
</html>

================================================
FILE: functional-tests/templates/content.py
================================================
# -*- coding: utf-8 -*-
from classes.util.misc import extend


def pages():
    parts = dict(
        base={
            'title': u'base',
            'mapInit':
            u"""
            DG.then(function() {
                map = DG.map('map', {
                center: [54.98, 82.89],
                zoom: 13,
                geoclicker: true,
                worldCopyJump: true,
                zoomAnimation: false
            });

                DG.control.location({position: 'bottomright'}).addTo(map);
                DG.control.scale().addTo(map);
                DG.control.ruler({position: 'bottomleft'}).addTo(map);
                DG.control.traffic().addTo(map);
            });"""
        },
        demo={
            'title': u'demo',
            'mapInit':
            u"""
            var  options,
             balloonHTML;

            DG.then(function () {
                map = DG.map('map', {
                    center: [54.980156831455, 82.897440725094],
                    zoom: 13,
                    geoclicker: true,
                    worldCopyJump: true,
                    zoomControl: false,
                    fullscreenControl: false,
                    zoomAnimation: false
                });

                // change control position on touch devices
                if (DG.Browser.touch) {
                    options = { position: 'bottomright' };
                }

                DG.control.zoom(options).addTo(map);
                DG.control.traffic(options).addTo(map);
                DG.control.location(options).addTo(map);
                DG.control.ruler(options).addTo(map);
                if (DG.screenfull.isAvailable()) {
                    DG.control.fullscreen(options).addTo(map);
                }
                balloonHTML = '<a href="http://www.2gis.ru/" target="_blank">\\n\\
                <img src="/2.0/img/2gis-logo.png" alt="2GIS" title="2GIS" width="146" height="70" style="border: none"></a>\\n\\
                <p>Компания «ДубльГИС»</p>Тел.: (383) 363-05-55<br />Адрес: г. Новосибирск, Карла Маркса площадь, 7<br />\\n\\
                (МФК «Сан Сити»), 13 этаж';

                marker = DG.marker([54.980156831455, 82.897440725094]).addTo(map).bindPopup(balloonHTML).openPopup();
            });
            """,
            'headStyle':
            u"""
            html,body { height: 100%; margin: 0; padding: 0; }
            .leaflet-touch .leaflet-bottom .dg-attribution { margin-top: 70px; }
            .leaflet-touch .leaflet-bottom .dg-zoom {margin: 40px 10px 40px 0; }
            """
        },
        draggableMarker={
            'title': u'draggableMarker',
            'mapInit':
            u"""
            DG.then(function () {
                map = DG.map('map', {
                    center: [54.981, 82.891],
                    zoom: 15,
                    zoomAnimation: false
                });

                marker = DG.marker([54.981, 82.891], {
                    draggable: true
                }).addTo(map);
            });
            """
        },
        groupBalloon={
            'title': u'groupBalloon',
            'mapInit':
            u"""
            DG.then(function() {
                var map,
                    popups = DG.featureGroup(),
                    coordinates = [];
                map = DG.map('map', {
                    center: [54.98, 82.89],
                    zoom: 13,
                    zoomAnimation: false
                });
                for (var i = 0; i < 10; i++) {
                    coordinates[0] = 54.98 - Math.random();
                    coordinates[1] = 82.89 + Math.random();
                    DG.popup()
                        .setLatLng(coordinates)
                        .setContent('Я балун №' + i)
                        .addTo(popups);
                }

                popups.addTo(map);
                map.fitBounds(popups.getBounds());
            });
            """
        },
        groupMarkerEvent={
            'title': u'groupMarkerEvent',
            'mapInit':
            u"""
             DG.then(function() {

                map = DG.map('map', {
                    center: [54.98, 82.89],
                    zoom: 10,
                    zoomAnimation: false
                });

                marker1 = DG.marker([54.96, 82.889]).addTo(map);
                marker2 = DG.marker([54.98, 82.893]).addTo(map);
                marker3 = DG.marker([54.847182907052186, 83.06230008602144]).addTo(map);

                group = DG.featureGroup([marker1, marker2, marker3]);
                group.addTo(map);
                group.on('click', function(e) {
                    map.setView([e.latlng.lat, e.latlng.lng],{animate: false});
                });
            });
            """
        },
        markerLabels={
            'title': u'markerLabels',
            'mapInit':
            u"""
             DG.then(function() {
                map = DG.map('map', {
                    center: [54.98, 82.89],
                    zoom: 15,
                    zoomAnimation: false
                });

                DG.marker([54.98, 82.89])
                    .addTo(map)
                    .bindLabel("static", {
                        static: true
                    });

                DG.marker([54.98, 82.88])
                    .addTo(map)
                    .bindLabel('default');
            });
            """

        },
        openBalloons={
            'title': u'openBalloons',
            'mapInit':
            u"""
                DG.then(function() {
                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13,
                        zoomAnimation: false
                    });

                    DG.popup([54.98, 82.89])
                        .setLatLng([54.98, 82.89])
                        .setContent('default')
                        .openOn(map);

                    myPopUp = DG.popup()
                        .setLatLng([54.98, 82.89])
                        .setContent('request');
                });
                function openPopUp() {myPopUp.openOn(map)};
            """,
            'controls':
            u"""
            <input id="showPopup" type="button" value="Открыть балун" onclick="openPopUp()"/>
            """
        },
        sprawlingBalloon={
            'title': u'sprawlingBalloon',
            'mapInit':
            u"""
            DG.then(function () {
                        latLng = DG.latLng([54.98, 82.89]);

                    map = DG.map('map', {
                        center: latLng,
                        zoom: 13,
                        fullscreenControl: false,
                        zoomControl: false,
                        zoomAnimation: false
                    });

                    document.getElementById('sprawling').onclick = function () {
                        DG.popup({
                            maxWidth: 350,
                            sprawling: true
                        })
                        .setLatLng(latLng)
                        .setContent('Я балун!')
                        .openOn(map);
                    };

                    document.getElementById('no-sprawling').onclick = function () {
                        DG.popup({
                            maxWidth: 350
                        })
                        .setLatLng(latLng)
                        .setContent('Я балун!')
                        .openOn(map);
                    };

                    document.getElementById('minWidth').onclick = function () {
                        DG.popup({
                            maxWidth: 350,
                            minWidth: 320
                        })
                        .setLatLng(latLng)
                        .setContent('Я балун!')
                        .openOn(map);
                    };
                });
                function resize(pixels){
                    document.getElementById('map').style.width = pixels + "px";
                    map.invalidateSize(false);
                }
            """,
            'controls':
            u"""
            <div>
                <input style="width: 300px;" type="button" id="sprawling" value="Sprawling"><br />
                <input style="width: 300px;" type="button" id="no-sprawling" value="No sprawling"><br />
                <input style="width: 300px;" type="button" id="minWidth" value="Minimal width 320px"><br />
                <input style="width: 300px;" type="button" id="small" value="Small map" onclick="resize(200)"><br />
                <input style="width: 300px;" type="button" id="mid" value="Medium map" onclick="resize(300)"><br />
                <input style="width: 300px;" type="button" id="large" value="Large map" onclick="resize(500)">
            </div>
            """,
            'style': u"""width: 300px; height: 150px;"""
        },
        scrollBarBaloon={
            'title': u'scrollBarBalloon',
            'mapInit':
            u"""
            DG.then(function () {
                        latLng = DG.latLng([54.98, 82.89]);

                    map = DG.map('map', {
                        center: latLng,
                        zoom: 13,
                        fullscreenControl: false,
                        zoomControl: false,
                        zoomAnimation: false
                    });

                    document.getElementById('scrollBar').onclick = function () {
                        DG.popup({
                            maxHeight: 300,
                        })
                        .setLatLng(latLng)
                        .setContent('Lorem ipsum dolor sit amet, consectetur adipisicing elit. Ducimus ipsam itaque velit aut error ipsa sunt neque, ut molestiae. Omnis officia architecto similique, enim et voluptates sunt doloremque error repudiandae, iure est a quisquam, nulla voluptatibus quis nostrum voluptas vel ipsa consequatur ipsum velit. Nam laudantium, nemo iste enim ut soluta et explicabo amet nulla impedit sequi animi consectetur alias repellendus, laboriosam dolor dolorum tenetur quod modi sunt sapiente recusandae, pariatur! Delectus nihil provident hic perferendis veniam atque id, ad ipsum error laudantium, quo praesentium qui! Odit saepe distinctio aperiam autem dolor beatae nam, nostrum voluptate, reprehenderit tenetur quidem aspernatur!')
                        .openOn(map);
                    };

                    document.getElementById('noMaxHeight').onclick = function () {
                        DG.popup()
                        .setLatLng(latLng)
                        .setContent('Lorem ipsum dolor sit amet, consectetur adipisicing elit. Facere, perspiciatis corrupti? Minima beatae sed delectus obcaecati, officia eos! Sint, excepturi facere iusto, sapiente facilis repellat. Eum facere, illo necessitatibus voluptatibus, illum quas. Cumque nisi incidunt, facere laboriosam asperiores nihil fugiat dolor dolorum sequi soluta consectetur non nulla vel praesentium omnis.')
                        .openOn(map);
                    };

                    document.getElementById('noScrollBar').onclick = function () {
                        DG.popup({
                            maxHeight: 300
                        })
                        .setLatLng(latLng)
                        .setContent('Lorem ipsum dolor sit amet, consectetur adipisicing elit. Voluptas numquam distinctio impedit, quod totam eveniet dolorum qui? Corporis praesentium ipsum officiis impedit quas, inventore laboriosam ipsam nobis soluta maxime delectus quasi voluptatem, tenetur obcaecati laudantium error. Velit expedita, reprehenderit natus nihil cupiditate doloribus quis? In obcaecati cupiditate vero laudantium maiores.')
                        .openOn(map);
                    };
                });
            """,
            'controls':
            u"""
            <div>
                <input style="width: 300px;" type="button" id="scrollBar" ><br />
                <input style="width: 300px;" type="button" id="noMaxHeight"><br />
                <input style="width: 300px;" type="button" id="noScrollBar"><br />
            </div>
            """,
            'style': u"""width: 300px; height: 500px;"""
        },
        boundsNsk={
            'title': u'boundsNsk',
            'mapInit':
            u"""
            DG.then(function() {
                map = DG.map('map', {
                    center: [54.98, 82.89],
                    zoom: 10,
                    maxBounds: [
                        [54.8220, 82.4304],
                        [55.1372, 83.3505]
                    ],
                    minZoom: 10,
                    maxZoom: 15,
                    zoomAnimation: false
                });
            });
            """,
            'style': 'width: 670px; height: 400px;'
        },
        clickEvent={
            'title': u'clickEvent',
            'mapInit':
            u"""
            DG.then(function() {
                    var clickedElement = document.getElementById('info'),
                    coords = [
                        [54.99, 82.88],
                        [54.985, 82.94],
                        [54.984, 82.925],
                        [54.981, 82.928]
                    ];

                map = DG.map('map', {
                    center: [54.98, 82.89],
                    zoom: 13,
                    zoomAnimation: false
                });

                map.on('click', function(e) {
                    clickedElement.innerHTML = 'map ' + e.latlng.lat + ', ' + e.latlng.lng;
                });

                DG.marker([54.98, 82.89])
                    .on('click', function() {
                        clickedElement.innerHTML = 'marker';
                    })
                    .addTo(map);

                DG.polygon(coords)
                    .on('click', function() {
                        clickedElement.innerHTML = 'polygon';
                    })
                    .addTo(map);
            });
            """,
            'style': u"width: 100%; height: 400px;"
        },
        lazyLoad={
            'title': u'lazyLoad',
            'getParams': u'?lazy=true'
        },
        notLazyLoad={
            'title': u'notLazyLoad',
            'getParams': u'?lazy=false'
        }
    )
    defaults = dict(
        style='width: 1000px; height: 600px;',
        loaderPath='..',
        dgLoader='data-id="dgLoader"'
    )
    return extend(defaults, parts)


================================================
FILE: functional-tests/tests/__init__.py
================================================
# -*- coding: utf-8 -*-
import os

import contesto
from contesto import config as cfg

contesto.config.add_config_file(os.path.abspath(os.path.dirname(__file__)) + "/config.ini")
contesto.config.add_config_file(os.path.abspath(os.path.dirname(__file__)) + "/config.my.ini")

config = cfg


================================================
FILE: functional-tests/tests/balloon_test.py
================================================
# -*- coding: utf-8 -*-
from classes.mapsapi_base_test import MapsAPIBaseTest
from config import config
from lode_runner.dataprovider import dataprovider


class Balloons(MapsAPIBaseTest):
    """
    Тесты балунов
    """
    @dataprovider([
        config.aut['local'] + u'/demo.html'
    ])
    def balloon_to_marker_test(self, url):
        """
        :param url: Адрес страницы
        Проверка появления маркера при закрытии балуна
        1.Кликаем в контрол закрытия балуна
        2.Проверяем видимость маркера
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.balloon_crossed.wait_present()
        self.page.balloon_crossed.close()
        self.assertTrue(self.page.marker.is_visible)

    @dataprovider([
        config.aut['local'] + u'/openBalloons.html'
    ])
    def balloon_default_open_test(self, url):
        """
        :param url: Адрес страницы
        Проверка програмного открытия балуна.
        1.Проверяем что открыт балун по умолчанию
        """
        self.driver.get(url)
        self.page.map.wait_init()
        balloon_text = self.page.balloon.get_content().text
        self.assertEqual('default', balloon_text)

    @dataprovider([
        config.aut['local'] + u'/openBalloons.html'
    ])
    def balloon_program_open_test(self, url):
        """
        :param url: Адрес страницы
        Проверка програмного открытия балуна.
        1.Проверяем что открыт балун по умолчанию
        2.Кликаем по кнопке "Открыть балун"
        3.Проверяем что открыт один новый балун
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.driver.find_element_by_css_selector('#showPopup').click()
        self.page.balloon.wait_close()
        self.page.balloon.wait_present()
        balloon = self.page.balloon.get_content()
        self.assertEqual(1, self.page.balloon.count())
        self.assertEqual('request', balloon.text)

    @dataprovider([
        config.aut['local'] + u'/groupBalloon.html'
    ])
    def balloon_group_open_test(self, url):
        """
        :param url:
        Проверка открытия группы балунов
        1.Проверяем количество открытых балунов на карте
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.balloon.wait_present()
        self.assertEqual(10, self.page.balloon.count())

    @dataprovider([
        (config.aut['local'] + u'/sprawlingBalloon.html', 'large', '350px'),
        (config.aut['local'] + u'/sprawlingBalloon.html', 'mid', '290px'),
        (config.aut['local'] + u'/sprawlingBalloon.html', 'small', '190px'),
    ])
    def balloon_sprawling_test(self, url, size, width):
        """
        :param url: Адрес страницы
        :param size: Размер карты(large - 500px, mid - 300px, small - 200px)
        :param width: Ширина балуна
        Проверка размера балуна с параметром sprawling на карте
        1.Выставляем размер карты
        2.Кликаем в создать балун
        3.Проверяем ширину
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.driver.find_element_by_css_selector("input#%s" % size).click()
        self.driver.find_element_by_css_selector('input#sprawling').click()
        balloon_width = self.page.balloon.width
        self.assertEqual(balloon_width, width)

    @dataprovider([
        (config.aut['local'] + u'/sprawlingBalloon.html', 'small', 'large', '350px'),
        (config.aut['local'] + u'/sprawlingBalloon.html', 'small', 'mid', '290px'),
        (config.aut['local'] + u'/sprawlingBalloon.html', 'large', 'small', '190px'),
    ])
    def balloon_sprawling_resize_test(self, url, start, end, width):
        """
        :param url: Адрес страницы
        :param start: С какого размера переключаемся (размеры в описаны balloon_sprawling_test)
        :param end: На какой переключаемся
        :param width: Какой размер должен принять балун
        Проверка размера балуна с параметром sprawling на большой карте
        1.Выставляем ширину карты
        2.Создаем балун
        3.Меняем ширину карты
        4.Приверяем ширину балуна
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.driver.find_element_by_css_selector("input#%s" % start).click()
        self.driver.find_element_by_css_selector('input#sprawling').click()
        self.driver.find_element_by_css_selector("input#%s" % end).click()
        balloon_width = self.page.balloon.width
        self.assertEqual(balloon_width, width)

    @dataprovider([
        (config.aut['local'] + u'/scrollBarBalloon.html', 'scrollBar', True),
        (config.aut['local'] + u'/scrollBarBalloon.html', 'noMaxHeight', False),
        (config.aut['local'] + u'/scrollBarBalloon.html', 'noScrollBar', False),
    ])
    def balloon_scroll_bar_test(self, url, type_, scroll_bar):
        """
        Проверка скроллбара
        :param url: Адрес страницы
        :param type_: Какой балун
        :param scroll_bar: Есть ли скролбар
        1.Кликаем в создать балун
        2.Проверяем наличие скролбара
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.driver.find_element_by_css_selector("input#%s" % type_).click()

        self.assertEqual(bool(self.page.balloon.scroll), scroll_bar)

    @dataprovider([
        (config.aut['local'] + u'/scrollBarBalloon.html', 'scrollBar', 300),
        (config.aut['local'] + u'/scrollBarBalloon.html', 'noScrollBar', 240),
    ])
    def balloon_max_height_test(self, url, type_, height):
        """
        Проверка скроллбара
        :param url: Адрес страницы
        :param type_: Какой балун
        :param height: Высота
        1.Кликаем в создать балун
        2.Проверяем высоту балуна
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.driver.find_element_by_css_selector("input#%s" % type_).click()

        balloon_height = self.page.balloon.height
        self.assertEqual(balloon_height, "%dpx" % height)


================================================
FILE: functional-tests/tests/bounds_test.py
================================================
# -*- coding: utf-8 -*-
from classes.mapsapi_base_test import MapsAPIBaseTest
from config import config
from lode_runner.dataprovider import dataprovider
from classes.util import scripts


class Bounds(MapsAPIBaseTest):
    """
    Тесты на ограничение зума и границ
    """
    @dataprovider([
        config.aut['local'] + u'/boundsNsk.html'
    ])
    def bound_min_zoom_script_test(self, url):
        """
        :param url: Адрес страницы
        Проверка ограничения минимального зума
        1.Выставляем зум меньше ограничения
        2.Проверяем что зум равен ограничению
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(scripts.SetScripts.set_zoom(9))
        zoom = self.page.console(scripts.GetScripts.getZoom)
        self.assertEqual(10, zoom)

    @dataprovider([
        config.aut['local'] + u'/boundsNsk.html'
    ])
    def bound_max_zoom_script_test(self, url):
        """
        :param url: Адрес страницы
        Проверка ограничения максимального зума
        1.Выставляем зум больше ограничения
        2.Проверяем что зум равен ограничению
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(scripts.SetScripts.set_zoom(16))
        zoom = self.page.console(scripts.GetScripts.getZoom)
        self.assertEqual(15, zoom)

    @dataprovider([
        config.aut['local'] + u'/boundsNsk.html'
    ])
    def bound_max_zoom_control_test(self, url):
        """
        :param url: Адрес страницы
        Проверка ограничения максимального зума
        1.Выставляем зум равный ограничению
        2.Кликаем в контрол zoom in
        3.Проверяем что зум равен ограничению
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(scripts.SetScripts.set_zoom(15))
        self.page.zoom_control_in.zoom_in_click()
        zoom = self.page.console(scripts.GetScripts.getZoom)
        self.assertEqual(15, zoom)

    @dataprovider([
        config.aut['local'] + u'/boundsNsk.html'
    ])
    def bound_min_zoom_control_test(self, url):
        """
        :param url: Адрес страницы
        Проверка ограничения минимального зума
        1.Выставляем зум равный ограничения
        2.Кликаем
        3.Проверяем что зум равен ограничению
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(scripts.SetScripts.set_zoom(10))
        self.page.zoom_control_out.zoom_out_click()
        zoom = self.page.console(scripts.GetScripts.getZoom)
        self.assertEqual(10, zoom)


================================================
FILE: functional-tests/tests/event_test.py
================================================
# -*- coding: utf-8 -*-
from classes.mapsapi_base_test import MapsAPIBaseTest
from config import config
from lode_runner.dataprovider import dataprovider
from classes.util.scripts import SetScripts
from classes.util import misc


class EventHandlers(MapsAPIBaseTest):
    @dataprovider([
        (config.aut['local'] + u'/clickEvent.html')
    ])
    def click_marker_test(self, url):
        """
        Проверка события click для маркера
        :param url: Адрес страницы
        1.Открываем страницу
        2.Кликаем в маркер
        3.Проверяем содержимое info
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.marker.click()
        info = self.page.map.info_elem()
        self.assertEqual(info.text, 'marker')

    @dataprovider([
        (config.aut['local'] + u'/clickEvent.html', {'lat': 54.99, 'lng': 82.73})
    ])
    def click_map_test(self, url, point):
        """
        Проверка события click для карты
        :param url: Адрес страницы
        :param point: Координаты на карте
        1.Открываем страницу
        2.Кликаем в координаты
        3.Проверяем содержимое info
        """
        self.driver.get(url)
        self.page.map.wait_init()
        info = self.page.map.info_elem()
        self.page.console(SetScripts.set_zoom(17))
        self.page.console(SetScripts.pan_to(point['lat'], point['lng']))
        self.page.map.center_click()
        self.assertEqual(info.text.split(' ')[0], 'map')
        coords = misc.coord_string_to_dict(info.text[4:])
        self.assertTrue(misc.coord_equals(point, coords, 2))

    @dataprovider([
        (config.aut['local'] + u'/clickEvent.html', {'lat': 54.985, 'lng': 82.911})
    ])
    def click_polygon_test(self, url, point):
        """
        Проверка события click для карты
        :param url: Адрес страницы
        :param point: Координаты на карте внутри полигона
        1.Открываем страницу
        2.Кликаем в координаты
        3.Проверяем содержимое info
        """
        self.driver.get(url)
        self.page.map.wait_init()
        info = self.page.map.info_elem()
        self.page.console(SetScripts.set_zoom(17))
        self.page.console(SetScripts.pan_to(point['lat'], point['lng']))
        self.page.map.center_click()
        self.assertEqual(info.text, 'polygon')


================================================
FILE: functional-tests/tests/firm_callout_test.py
================================================
# -*- coding: utf-8 -*-
from classes.mapsapi_base_test import MapsAPIBaseTest
from config import config
from lode_runner.dataprovider import dataprovider
from classes.util import scripts
from classes.WAPI.dataWorker import FirmData
import classes.util.misc as misc
import classes.util.link_generator as links


class FirmCallout(MapsAPIBaseTest):
    """
    Тесты на сallout фирмы
    """
    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254,
        141265770417218
    )
    ])
    def firm_name_test(self, url, lat, lng, firm_id):
        """
        Проверка заголовка фирмы
        1.Открываем калаут фирмы
        2.Проверяем заголовок
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(scripts.SetScripts.pan_to(lat, lng))
        self.page.console(scripts.SetScripts.set_zoom(17))
        self.page.map.center_click()
        self.page.build_callout.wait_present()
        self.page.build_callout.open_firm_list()
        self.page.build_callout.open_firm_by_id(firm_id)
        callout_text = self.page.firm_callout.header
        f = FirmData(firm_id)
        self.assertEqual(f.firm_name, callout_text)

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254
    )
    ])
    def firm_back_list_test(self, url, lat, lng):
        """
        Проверка кнопки назад (в здании с мн. организаций)
        1.Открываем калаут фирмы
        2.Нажимаем назад
        3.Проверяем наличие списка организаций
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(scripts.SetScripts.pan_to(lat, lng))
        self.page.console(scripts.SetScripts.set_zoom(17))
        self.page.map.center_click()
        self.page.build_callout.wait_present()
        self.page.build_callout.open_firm_list()
        self.page.build_callout.open_firm_by_index(1)
        self.page.firm_callout.back()
        self.assertTrue(self.page.firm_list.list_present())

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.987722587459736,
        82.88787066936494
    )
    ])
    def firm_back_build_test(self, url, lat, lng):
        """
        Проверка кнопки назад (к зданию)
        1.Открываем калаут фирмы
        2.Нажимаем назад
        3.Проверяем наличие колаута здания
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(scripts.SetScripts.pan_to(lat, lng))
        self.page.console(scripts.SetScripts.set_zoom(17))
        self.page.map.center_click()
        self.page.build_callout.wait_present()
        self.page.build_callout.open_firm_by_index(1)
        self.page.firm_callout.back()
        self.assertTrue(self.page.build_callout.is_visible)

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.987722587459736,
        82.88787066936494,
        17,
        ['2gis.ru', 'novosibirsk', 'center', 82.89, 54.99, 'zoom', '17',
         'routeTab', 'rsType', 'bus', 'to', 82.89, 54.99, 'Новосибирск, Ватутина, 16']
    ), (
        config.aut['local'] + u'/base.html',
        -33.44449709158904,
        -70.6516680121422,
        18,
        ['2gis.cl', 'santiago', 'center', -70.65, -33.44, 'zoom', '18',
         'routeTab', 'rsType', 'bus', 'to', -70.65, -33.44, 'Santiago, Avenida Libertador Bernardo O\'Higgins, 1112']
    )
    ])
    def firm_route_to(self, url, lat, lng, zoom, parts):
        """
        Проверка ссылки на проехать до
        1.Открываем калаут фирмы
        2.Проверяем атирибут ссылки "Проехать сюда"
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(scripts.SetScripts.pan_to(lat, lng))
        self.page.console(scripts.SetScripts.set_zoom(zoom))
        self.page.map.center_click()
        self.page.build_callout.wait_present()
        self.page.build_callout.open_firm_by_index(1)
        route = self.page.firm_callout.route_link
        self.assertTrue(misc.check_route(route.get_attribute('href'), parts))

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254,
        141265770417218
    )
    ])
    def firm_photo_test(self, url, lat, lng, firm_id):
        """
        Проверка наличия фото у фирмы
        1.Открыть фирму с фото
        2.Проверить наличие ссылки
        3.Проверить url ссылки
        4.Проверить количество фото
        """
        self._open_firm(url, lat, lng, firm_id)
        photo = self.page.firm_callout.photo
        self.assertTrue(photo.is_displayed())
        f = FirmData(firm_id)
        num = misc.to_int(photo.text)
        self.assertEqual(f.photo_count(), num)
        link = links.photo_link(firm_id)
        self.assertEqual(link, photo.get_attribute('href'))

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254,
        141265771060872
    )
    ])
    def firm_rating_test(self, url, lat, lng, firm_id):
        """
        Проверка наличия рейтинга у фирмы
        1.Открыть фирму с рейтингом
        2.Проверить наличие рейтинга
        3.Проверить url ссылки
        4.Проверить количество отзывов
        """
        self._open_firm(url, lat, lng, firm_id)
        stars = self.page.firm_callout.stars
        reviews = self.page.firm_callout.reviews
        f = FirmData(firm_id)
        self.assertTrue(stars.is_displayed())
        self.assertEqual(reviews.get_attribute('href'), links.reviews_link(firm_id))
        reviews_count = misc.to_int(reviews.text)
        self.assertEqual(reviews_count, f.review_count)

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.97883,
        82.872775,
        141265769707278
    )
    ])
    def firm_address_test(self, url, lat, lng, firm_id):
        """
        Проверка наличия адреса
        1.Открыть фирму
        2.Проверить наличие адреса
        3.Проверить адрес
        """
        self._open_firm(url, lat, lng, firm_id)
        f = FirmData(firm_id)
        self.assertTrue(self.page.firm_callout.address.is_displayed())
        self.assertEqual(self.page.firm_callout.address.text, f.address_name)

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254,
        141265771060872
    )
    ])
    def firm_address_comment_test(self, url, lat, lng, firm_id):
        """
        Проверка наличия комментария к адресу
        1.Открыть фирму с комментарием
        2.Праверить наличие комментария
        """
        self._open_firm(url, lat, lng, firm_id)
        f = FirmData(firm_id)
        self.assertTrue(self.page.firm_callout.address.is_displayed())
        full_adress = misc.address_and_comment(f.address_name, f.address_comment)
        self.assertEqual(self.page.firm_callout.address.text, full_adress)

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254,
        141265771060872
    ), (
        config.aut['local'] + u'/base.html',
        54.9810307939813,
        82.87442207336427,
        141265769728580
    )
    ])
    def firm_telephone_count_test(self, url, lat, lng, firm_id):
        """
        Проверка наличия и количества телефонов
        1.Открывем фирму
        2.Получаем количество телефонов (из API)
        3.Проверяем количество телефонов
        """
        self._open_firm(url, lat, lng, firm_id)
        f = FirmData(firm_id)
        phones_wapi = f.get_phones()
        phones_num = len(phones_wapi)
        phones_callout = self.page.firm_callout.phones()
        self.assertEqual(phones_num, len(phones_callout))

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254,
        141265771060872
    )
    ])
    def firm_telephone_comment_test(self, url, lat, lng, firm_id):
        """
        Проверка наличия комментария к телефону
        1.Открываем фирму
        2.Проверяем наличия комментария к телефону
        """
        self._open_firm(url, lat, lng, firm_id)
        f = FirmData(firm_id)
        phones_wapi = f.get_phones()
        phones_callout = self.page.firm_callout.phones()
        phone_and_comment = misc.phone_and_comment(phones_wapi[0]['text'], phones_wapi[0]['comment'])
        self.assertEqual(phones_callout[0].text, phone_and_comment)

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254,
        141265770417218
    ), (
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254,
        141265770847007
    )
    ])
    def firm_website_count_test(self, url, lat, lng, firm_id):
        """
        Проверка наличия ссылки на вебсайт
        1.Открываем фирму
        2.Проверяем наличие ссылки на вебсайт
        3.Проверяем количество ссылок
        """
        self._open_firm(url, lat, lng, firm_id)
        f = FirmData(firm_id)
        websites_wapi = f.get_websites()
        websites_callout = self.page.firm_callout.websites()
        self.assertEqual(len(websites_callout), len(websites_wapi))
        self.assertEqual(websites_callout[0].text, websites_wapi[0]['text'])

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254,
        141265771881838
    )])
    def firm_email_test(self, url, lat, lng, firm_id):
        """
        Проверка наличия email
        1.Открываем фирму
        2.Проверяем наличие email
        3.Проверяем ссыль на мейл
        """
        self._open_firm(url, lat, lng, firm_id)
        f = FirmData(firm_id)
        email = self.page.firm_callout.email
        self.assertEqual(email.text, f.get_emails()[0]['text'])
        self.assertEqual(email.get_attribute('href'), "mailto:%s" % f.get_emails()[0]['value'])

    # для простого, списка и таблицы
    def firm_schedule(self):
        """
        Проверка наличия расписания
        1.Открываем фирму
        2.Проверяем наличие расписания
        3.Проверяем наличие подсказки
        """
        pass

    def firm_schedule_wrapper_list(self):
        """
        Проверка расписания-списка
        1.Открываем фирму
        2.Проверяем расписание на сегодня (для всех языков)
        3.Кликаем в врапер
        4.Проверяем наличие списка
        5.Отсутсвие посдсказки на сегодня
        """
        pass

    def firm_schedule_wrapper_table(self):
        """
        Проверка расписания-таблицы
        1.Открываем фирму
        2.Проверяем расписание на сегодня (для всех языков)
        3.Кликаем в врапер
        4.Проверяем наличие таблицы
        5.Отсутсвие посдсказки на сегодня
        """
        pass

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254,
        141265771060872
    )
    ])
    def firm_rubrics_test(self, url, lat, lng, firm_id):
        """
        Проверка рубрик
        1.Открываем фирму
        2.Проверяем количество рубрик
        3.Проверяем порядок(первая, последняя, в сеередине с учетом primary)
        """
        self._open_firm(url, lat, lng, firm_id)
        f = FirmData(firm_id)
        primary = self.page.firm_callout.primary_rubrics
        self.assertEqual(primary[0].text, f.get_rubrics_primary()[0]['name'])
        primary_last = len(f.get_rubrics_primary()) - 1
        self.assertEqual(primary[primary_last].text, f.get_rubrics_primary()[primary_last]['name'])
        additional = self.page.firm_callout.additional_rubrics
        self.assertEqual(additional[0].text, f.get_rubrics_additional()[0]['name'])
        additional_last = len(f.get_rubrics_additional()) - 1
        self.assertEqual(additional[additional_last].text,
                         f.get_rubrics_additional()[additional_last]['name'])

    @dataprovider([(
        config.aut['local'] + u'/base.html',
        54.980678320392336,
        82.89860486984254,
        141265771060872
    )
    ])
    def firm_scroll_bar_test(self, url, lat, lng, firm_id):
        """
        Проверка наличия скролл-бара
        1.Открываем фирму со скроллбаром
        2.Проверяем его наличия
        """
        self._open_firm(url, lat, lng, firm_id)
        self.assertTrue(self.page.firm_callout.scroll.is_displayed())

    def _open_firm(self, url, lat, lng, firm_id):
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(scripts.SetScripts.pan_to(lat, lng))
        self.page.console(scripts.SetScripts.set_zoom(17))
        self.page.map.center_click()
        self.page.build_callout.wait_present()
        self.page.build_callout.open_firm_list()
        self.page.build_callout.open_firm_by_id(firm_id)


================================================
FILE: functional-tests/tests/geo_clicker_test.py
================================================
# -*- coding: utf-8 -*-
from classes.mapsapi_base_test import MapsAPIBaseTest
from config import config
from lode_runner.dataprovider import dataprovider
from classes.util.scripts import SetScripts
from classes.util.scripts import GetScripts
from classes.WAPI.dataWorker import GeoData
from classes.WAPI.dataWorker import FirmData
from classes.WAPI.dataWorker import GalleryData


class GeoClicker(MapsAPIBaseTest):
    """
    Тесты геокликера.
    В данных тестах проверяется открытие нужных колаутов в соответствии с координатами и зумом.
    Кроме того для описания переводов используются словари с ключами языков.
    """
    not_found = {
        'ru': u"Это место мы ещё не успели изучить",
        'en': u"We haven't collected info about this place yet",
        'cs': u"O tomto místě zatím nemáme informace",
        'es': u"Todavía no hemos recopilado la información sobre este lugar",
        'it': u"Non disponiamo ancora di informazioni su questo posto"
    }
    city = {
        'ru': u"Город",
        'en': u"City",
        'cs': u"Město",
        'es': u"Ciudad",
        'it': u"Сittà"
    }
    district = {
        'ru': u"Район",
        'en': u"District",
        'cs': u"Městská část",
        'es': u"Comuna",
        'it': u"Municipalità"
    }
    street = {
        'ru': u"Улица",
        'en': u"Street",
        'cs': u"Ulice",
        'es': u"Calle",
        'it': u"Via"
    }

    @dataprovider([
        (config.aut['local'] + u'/base.html', 54.98, 82.32)
    ])
    def callout_unknown_place_test(self, url, lat, lng):
        """
        :param url: Адрес страницы
        :param lat: Широта
        :param lng: Долгота
        Тест на проверку колаута неизвестного места.
        1.Перемещаемся к координатам
        2.Кликаем в центр
        3.Проверяем открытие калаута
        4.Проверяем содержимое колаута для всех языков
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.driver.execute_script(SetScripts.pan_to(lat, lng))
        self.page.map.center_click()
        self.page.unkown_place.wait_present()
        self.assertTrue(self.page.unkown_place.is_visible)
        for lang in self.not_found:
            self.driver.execute_script(SetScripts.set_lang(lang))
            header = self.page.unkown_place.header
            self.assertEqual(self.not_found[lang], header)

    @dataprovider([
        config.aut['local'] + u'/base.html'
    ])
    def callout_city_place_test(self, url):
        """
        :param url: Адрес страницы
        Тест на проверку колаута города.
        1.Изменяем изначальный зум к 8
        2.Кликаем в центр
        3.Проверяем открытие калаута
        4.Проверяем название города
        5.Проверяем информацию о геообъекте на всех языках
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.driver.execute_script(SetScripts.set_zoom(8))
        center = self.driver.execute_script(GetScripts.getCenter)
        g = GeoData(center, 8)
        self.page.map.center_click()
        self.page.place_callout.wait_present()
        self.assertEqual(self.page.place_callout.header, g.city_name)
        for lang in self.city:
            self.driver.execute_script(SetScripts.set_lang(lang))
            purpose = self.page.place_callout.purpose
            self.assertEqual(self.city[lang], purpose)

    @dataprovider([
        config.aut['local'] + u'/base.html'
    ])
    def callout_district_place_test(self, url):
        """
        :param url: Адрес страницы
        Тест на проверку колаута района.
        1.Кликаем в центр
        2.Проверяем открытие калаута
        3.Проверяем название района
        4.Проверяем адрес района
        5.Проверяем информацию о геообъекте на всех языках
        """
        self.driver.get(url)
        self.page.map.wait_init()
        center = self.driver.execute_script(GetScripts.getCenter)
        self.page.map.center_click()
        self.page.addresed_place_callout.wait_present()
        zoom = self.driver.execute_script(GetScripts.getZoom)
        g = GeoData(center, zoom)
        district_addr = g.place_address
        callout_addr = self.page.addresed_place_callout.drilldown
        self.assertEqual(self.page.addresed_place_callout.header, g.district_name)
        self.assertEqual(callout_addr, district_addr)
        for lang in self.district:
            self.driver.execute_script(SetScripts.set_lang(lang))
            purpose = self.page.addresed_place_callout.purpose
            self.assertEqual(self.district[lang], purpose)

    @dataprovider([
        (config.aut['local'] + u'/base.html', 54.9802611969944, 82.89837956428528)

    ])
    def callout_building_name_test(self, url, lat, lng):
        """
        :param url: Адрес страницы
        :param lat: Широта
        :param lng: Долгота
        Проверка здания с названием.
        1.Перемещаемся к координатам
        2.Изменяем изначальный зум к 18
        3.Кликаем в центр
        4.Проверяем наличие названия в заголовке
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.driver.execute_script(SetScripts.pan_to(lat, lng))
        self.driver.execute_script(SetScripts.set_zoom(18))
        self.page.map.center_click()
        center = self.driver.execute_script(GetScripts.getCenter)
        self.page.build_callout.wait_present()
        g = GeoData(center, 18)
        self.assertEqual(g.build_name, self.page.build_callout.header)

    @dataprovider([
        (config.aut['local'] + u'/base.html', 54.98511556781472, 82.85259425640108)

    ])
    def callout_building_without_name_test(self, url, lat, lng):
        """
        :param url: Адрес страницы
        :param lat: Широта
        :param lng: Долгота
        Проверка здания без названия.
        1.Перемещаемся к координатам
        2.Изменяем изначальный зум к 18
        3.Кликаем в центр
        4.Проверяем наличие адреса в заголовке
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(SetScripts.set_zoom(18))
        self.page.console(SetScripts.pan_to(lat, lng))
        self.page.map.center_click()
        center = self.page.console(GetScripts.getCenter)
        g = GeoData(center, 18)
        self.page.build_callout.wait_present()
        self.assertEqual(g.build_name, self.page.build_callout.header)

    @dataprovider([
        (config.aut['local'] + u'/base.html', 54.98127706190138, 82.88240969181062)
    ])
    def callout_attraction_test(self, url, lat, lng):
        """
        :param url: Адрес страницы
        :param lat: Широта
        :param lng: Долгота
        Проверка калаута достопремичательности.
        1.Перемещаемся к координатам
        2.Изменяем изначальный зум к 18
        3.Кликаем в центр
        4.Проверяем наличие калаута
        6.Проверяем заголовок калаута
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(SetScripts.pan_to(lat, lng))
        self.page.console(SetScripts.set_zoom(18))
        self.page.map.center_click()
        self.page.attraction_callout.wait_present()
        center = self.page.console(GetScripts.getCenter)
        g = GeoData(center, 18)
        self.assertTrue(self.page.attraction_callout.is_visible)
        self.assertEqual(g.attraction_name, self.page.attraction_callout.header)

    @dataprovider([
        (config.aut['local'] + u'/base.html', 54.9833825909448, 82.89679169654848)
    ])
    def callout_street_test(self, url, lat, lng):
        """
        :param url: Адрес страницы
        :param lat: Широта
        :param lng: Долгота
        Проверка калаута улицы.
        1.Перемещаемся к координатам
        2.Изменяем изначальный зум к 18
        3.Кликаем в центр
        4.Проверяем наличие калаута
        5.Проверяем название улицы
        6.Проверяем расположение улицы
        7.Проверяем информацию о геообъекте на всех языках
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(SetScripts.pan_to(lat, lng))
        self.page.console(SetScripts.set_zoom(18))
        self.page.map.center_click()
        center = self.page.console(GetScripts.getCenter)
        g = GeoData(center, 18)
        self.page.addresed_place_callout.wait_present()
        self.assertTrue(self.page.addresed_place_callout.is_visible)
        self.assertEqual(g.street_name, self.page.addresed_place_callout.header)
        self.assertEqual(self.page.addresed_place_callout.drilldown, g.street_address)
        for lang in self.street:
            self.page.console(SetScripts.set_lang(lang))
            self.assertEqual(self.page.addresed_place_callout.purpose, self.street[lang])

    @dataprovider([
        (config.aut['local'] + u'/base.html', '54.986870015252265', '82.8704744636')
    ])
    def callout_attraction_text_test(self, url, lat, lng):
        """
        :param url: Адрес страницы
        :param lat: Широта
        :param lng: Долгота
        Проверка калаута памятника с текстом.
        1.Перемещаемся к координатам
        2.Изменяем изначальный зум к 18
        3.Кликаем в центр
        4.Проверяем наличие калаута
        6.Проверяем заголовок калаута
        7.Проверяем наличие враппера
        8.Проверяем текст
        9.Кликаем во враппер
        10.Проверяем отсутствие враппера
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(SetScripts.set_zoom(18))
        self.page.console(SetScripts.pan_to(lat, lng))
        self.page.map.center_click()
        self.page.attraction_callout_wrapped.wait_present()
        center = self.page.console(GetScripts.getCenter)
        g = GeoData(center, 18)
        self.assertTrue(self.page.attraction_callout_wrapped.is_visible)
        self.assertEqual(g.attraction_name, self.page.attraction_callout.header)
        self.assertTrue(self.page.attraction_callout_wrapped.wrapper())
        self.assertEqual(g.attraction_description, self.page.attraction_callout_wrapped.text)
        self.page.attraction_callout_wrapped.unwrap()
        self.assertFalse(self.page.attraction_callout_wrapped.wrapper())

    @dataprovider([
        (config.aut['local'] + u'/base.html', '54.98088611087379', '82.89719912975313', 141265770417218)
    ])
    def callout_poi_test(self, url, lat, lng, firm_id):
        """
        :param url: Адрес страницы
        :param lat: Широта
        :param lng: Долгота
        :param firm_id:
        Проверка калаута POI.
        1.Перемещаемся к координатам
        2.Изменяем изначальный зум к 18
        3.Кликаем в центр
        4.Проверяем наличие калаута
        6.Проверяем заголовок калаута
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(SetScripts.set_zoom(18))
        self.page.console(SetScripts.pan_to(lat, lng))
        self.page.map.center_click()
        self.page.firm_callout.wait_present()
        f = FirmData(firm_id)
        self.assertEqual(self.page.firm_callout.header, f.firm_name)

    @dataprovider([
        (config.aut['local'] + u'/base.html', '-33.44692090822703', '-70.65750718116762', 14215121979385186)
    ])
    def callout_poi_gallery_test(self, url, lat, lng, firm_id):
        """
        :param url: Адрес страницы
        :param lat: Широта
        :param lng: Долгота
        :param firm_id:
        Проверка калаута памятника с текстом.
        1.Перемещаемся к координатам
        2.Изменяем изначальный зум к 18
        3.Кликаем в центр
        4.Проверяем наличие калаута
        6.Проверяем заголовок калаута
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.console(SetScripts.pan_to(lat, lng))
        self.page.console(SetScripts.set_zoom(19))
        self.page.map.center_click()
        self.page.build_callout.wait_present()
        g = GalleryData(firm_id)
        self.assertEqual(self.page.build_callout.header, g.gallery_name)


================================================
FILE: functional-tests/tests/loader_test.py
================================================
# -*- coding: utf-8 -*-
from classes.mapsapi_base_test import MapsAPIBaseTest
from config import config
from lode_runner.dataprovider import dataprovider
from classes.util.scripts import SetScripts


class LoaderTest(MapsAPIBaseTest):
    """
    Тесты параметров лоадера mapsapi
    """
    @dataprovider([
        (config.aut['local'] + u'/lazyLoad.html')
    ])
    def loader_dg_then_add_app_test(self, url):
        """
        :param url: Адрес страницы
        Тест на проверку ленивой загрузки
        1.Открываем страницу
        2.Проверяем отсутсвие скрипта
        3.Выполняем DG.then
        4.Проверяем наличие скрипта
        """
        self.driver.get(url)
        self.assertTrue(not self.page.sources.app_js_present)
        self.driver.execute_script(SetScripts.dg_then())
        self.assertTrue(self.page.sources.app_js_present)

    @dataprovider([
        (config.aut['local'] + u'/notLazyLoad.html')
    ])
    def loader_lazy_false_add_app_test(self, url):
        """
        :param url: Адрес страницы
        Тест на проверку ленивой загрузки
        1.Открываем страницу
        4.Проверяем наличие скрипта
        """
        self.driver.get(url)
        self.assertTrue(self.page.sources.app_js_present)


================================================
FILE: functional-tests/tests/marker_test.py
================================================
# -*- coding: utf-8 -*-
from classes.mapsapi_base_test import MapsAPIBaseTest
from config import config
from lode_runner.dataprovider import dataprovider
from classes.util.scripts import SetScripts
from classes.util.scripts import GetScripts


class Marker(MapsAPIBaseTest):

    @dataprovider([
        config.aut['local'] + u'/demo.html'
    ])
    def marker_to_balloon_test(self, url):
        """
        :param url: Адрес страницы
        Проверка появления балуна при клике в маркер
        1.Кликаем в контрол закрытия балуна
        2.Кликаем в маркер
        3.Проверяем наличие балуна
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.balloon_crossed.wait_present()
        self.page.balloon_crossed.close()
        self.page.marker.wait_present()
        self.page.marker.click()
        self.page.balloon_crossed.wait_present()
        self.assertTrue(self.page.balloon_crossed.is_visible)

    @dataprovider([
        config.aut['local'] + u'/draggableMarker.html'
    ])
    def marker_drag_test(self, url):
        """
        :param url: Адрес страницы
        Проверка изменения координат маркера
        1.Драгаем маркер на 10px вниз и вправо
        2.Проверяем значение абзацев с координатами
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.marker.drag_marker(10, 10)
        lat = self.page.marker.get_lat()
        lng = self.page.marker.get_lng()
        self.assertEqual(lat, '54.981')
        self.assertEqual(lng, '82.891')

    @dataprovider([
        config.aut['local'] + u'/markerLabels.html'
    ])
    def marker_static_label_test(self, url):
        """
        :param url: Адрес страницы
        Проверка наличия статического лэйбла у маркера
        1.Проверяем наличие лейбла у маркера
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.assertEqual(self.page.marker.get_labels()[0].text, u'static')

    @dataprovider([
        config.aut['local'] + u'/markerLabels.html'
    ])
    def marker_dynamic_label_test(self, url):
        """
        :param url: Адрес страницы
        Проверка наличия стандартного лейбла у маркера
        1.Наводим мышь на маркер
        2.Проверяем наличие лейбла
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.marker.hover_marker(1)
        text = self.page.marker.get_labels()[1].text
        self.assertEqual(text, u'default')

    @dataprovider([
        config.aut['local'] + u'/demo.html'
    ])
    def marker_program_open_test(self, url):
        """
        :param url: Адрес страницы
        Проверка возможности програмного открытия маркеров
        1.Закрываем колаут
        2.Открываем его программно
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.balloon_crossed.close()
        self.page.console(SetScripts.open_marker())
        self.assertTrue(self.page.balloon_crossed.is_visible)

    @dataprovider([
        config.aut['local'] + u'/groupMarkerEvent.html'
    ])
    def marker_group_events_test(self, url):
        """
        :param url: Адрес страницы
        Проверка обработки событиев у маркеров
        1.Кликаем в маркер 3
        2.Проверяем изменение координат карты
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.marker.click(2)
        center = self.page.console(GetScripts.getCenter)
        lat = '%.3f' % center['lat']
        lng = '%.3f' % center['lng']
        self.assertEqual(lat, self.page.marker.get_lat('marker3'))
        self.assertEqual(lng, self.page.marker.get_lng('marker3'))

    @dataprovider([
        config.aut['local'] + u'/groupMarkerEvent.html'
    ])
    def marker_group_bounds_test(self, url):
        """
        :param url: Адрес страницы
        Проверка подстройки границ под положение маркеров
        1.Выставляем большой зум
        2.Выполняем fitBounds по маркерам
        2.Проверяем изменение координат карты и зума
        """
        self.driver.get(url)
        self.page.map.wait_init()
        self.page.map.set_zoom(17)
        self.page.console('map.fitBounds(group.getBounds())')
        center = self.page.console(GetScripts.getCenter)
        lat = '%.3f' % center['lat']
        lng = '%.3f' % center['lng']
        self.assertEqual(lat, '54.914')
        self.assertEqual(lng, '82.976')


================================================
FILE: functional-tests/tests/ruler_test.py
================================================
# -*- coding: utf-8 -*-
from classes.mapsapi_base_test import MapsAPIBaseTest
from config import config
from lode_runner.dataprovider import dataprovider
from classes.util import scripts


class Ruler(MapsAPIBaseTest):
    """
    Тесты на линейку
    """
    def ruler_control(self):
        """
        Проверка контрола линеки
        1.Кликаем в контрол линейки
        2.Кликаем в центр карты
        3.Проверяем наличие вершин линейки
        4.Кликаем в контрол линейки
        5.Проверяем отсутсвие вершин линейки
        """
        pass

    def ruler_two_vertexes(self):
        """
        Проверка появления ребер линейки
        1.Кликаем в контрол
        2.Кликаем в центр карты
        3.Кликаем левее на 150px
        4.Проверяем наличие 2х вершин
        5.Проверяем расстояние
        5.Проверяем наличие ребра
        """
        pass

    def ruler_vertex_in_middle(self):
        """
        Проверка добаления не крайних вершин
        1.Кликаем в контрол линейки
        2.Кликаем в центр карты
        3.Кликаем на 300px левее
        4.Кликаем на 150px правее
        5.Проверяем наличие 3х вершин
        6.Проверяем что узел добавился в середину
        """
        pass

    def ruler_vertex_in_end(self):
        """
        Проверка добаления точки в конце
        1.Кликаем в контрол линейки
        2.Кликаем в центр карты
        3.Кликаем на 150px левее
        4.Кликаем на 150px левее
        5.Проверяем наличие 3х вершин
        6.Проверяем что узел добавился в конец
        """
        pass

    def ruler_hover_vertex(self):
        """
        Проверка ховера не полседнего узла
        1.Кликаем в контрол линейки
        2.Кликаем в центр карты
        3.Кликаем на 150px левее
        4.Кликаем на 150px левее
        5.Перемещаем курсор на 150px правее
        6.Проверяем появление маркера
        7.Проверяем расстояние
        8.Перемещаем на 150px правее
        9.Провяем наличие маркера
        10.Проверяем расстояние на 0
        """
        pass

    def ruler_hover_line(self):
        """
        Проверка ховера линии
        1.Кликаем в контрол линейки
        2.Кликаем в центр карты
        3.Кликаем на 300px левее
        4.Перемещаем на 150px правее
        5.Проверяем наличе маркера
        """
        pass

    def ruler_delete_last(self):
        """
        Проверка удаления единственного узла
        1.Кликаем в контрол линейки
        2.Кликаем в центр карты
        3.Ховерим узел
        4.Кликаем в крест в маркере
        5.Проверяем отсутствие узлов
        """
        pass

    def ruler_delete_first_in_two(self):
        """
        Проверка удаления первого в случае двух узлов
        1.Кликаем в контрол линейки
        2.Кликаем в центр карты
        3.Кликам на 150px левее
        4.Удаляем первый узел
        5.Проверяем что остался только один узел
        6.Проверяем что узел остался на месте 2го
        7.Проверяем наличие маркера и значение в '0м'
        """
        pass

    def ruler_delete_last_in_two(self):
        """
        Проверка удаления первого в случае двух узлов
        1.Кликаем в контрол линейки
        2.Кликаем в центр карты
        3.Кликам на 150px левее
        4.Удаляем второй узел
        5.Проверяем что остался только один узел
        6.Проверяем что узел остался на месте 1го
        7.Проверяем наличие маркера и значение в '0м'
        """
        pass

    def ruler_delete_last_in_many(self):
        """
        Проверка удаления последнего (3 и более узла)
        1.Кликам в контрол линейки
        2.Кликаем в центр карты
        3.Кликам на 150px левее
        4.Кликам на 150px левее
        5.Удаляем последний
        6.Проверяем что маркер появился на втором
        """
        pass

    def ruler_delete_first_in_many(self):
        """
        Проверка удаления первого (3 и более узла)
        1.Кликам в контрол линейки
        2.Кликаем в центр карты
        3.Кликам на 150px левее
        4.Кликам на 150px левее
        5.Удаляем первый
        6.Ховерим второй
        7.Проверяем маркер и '0м'
        """
        pass

    def ruler_delete_middle_in_many(self):
        """
        Проверка удаления среднего
        1.Кликаем в контрол линейки
        2.Кликаем в центр карты
        3.Кликаем на 150px левее и 150px выше
        4.Кликаем на 150px левее и 150px ниже
        5.Удаляем второй узел
        6.Проверяем что вершины 2
        7.Проверяем что ребро 1
        8.Проверяем расстояние в маркере последней вершины
        """
        pass

    def ruler_drag_last(self):
        """
        Проверка драга последнего
        1.Кликам в контрол линейки
        2.Кликаем в центр карты
        3.Кликам на 150px левее
        4.Кликам на 150px левее
        5.Перемещаем последний узел на 100px
        6.Проверяем что переместился нужный узел
        7.Проверяем значения расстояния в последнем маркере
        """
        pass

    def ruler_drag_first(self):
        """
        Проверка драга первого
        1.Кликам в контрол линейки
        2.Кликаем в центр карты
        3.Кликам на 150px левее
        4.Кликам на 150px левее
        5.Перемещаем первий узел на 100px
        6.Проверяем что переместился нужный узел
        7.Проверяем значения расстояния в последнем
        8.Проверяем значение расстояния в первом на 0
        """
        pass

    def ruler_drag_middle(self):
        """
        Проверка драга среднего
        1.Кликам в контрол линейки
        2.Кликаем в центр карты
        3.Кликам на 150px левее
        4.Кликам на 150px левее
        5.Перемещаем средний узел на 100px вверх
        6.Проверяем что переместился нужный узел
        7.Проверяем значения расстояния
        """
        pass


================================================
FILE: functional-tests/tests/zoom_test.py
================================================
# -*- coding: utf-8 -*-
from classes.mapsapi_base_test import MapsAPIBaseTest
from config import config
from lode_runner.dataprovider import dataprovider
from classes.util.scripts import GetScripts


class Zoom(MapsAPIBaseTest):

    @dataprovider([
        config.aut['local'] + u'/base.html'
    ])
    def zoomIn_click_test(self, url):
        """
        :param url: Адрес страницы
        Проверка контрола зума +.
        1.Получаем зум страницы
        2.Кликаем в контрол +
        3.Проверяем что зум стал на единицу больше
        """
        self.driver.get(url)
        self.page.map.wait_init()
        zoom_start = self.page.console(GetScripts.getZoom)
        self.page.zoom_control_in.zoom_in_click()
        zoom_end = self.page.console(GetScripts.getZoom)
        self.assertEqual(zoom_end - zoom_start, 1)

    @dataprovider([
        config.aut['local'] + u'/base.html'
    ])
    def zoomOut_click_test(self, url):
        """
        :param url: Адрес страницы
        Проерка контрола зума -.
        1.Получаем зум страницы
        2.Кликаем в контрол -
        3.Проверяем что зум стал на единицу меньше
        """
        self.driver.get(url)
        self.page.map.wait_init()
        zoom_start = self.page.console(GetScripts.getZoom)
        self.page.zoom_control_out.zoom_out_click()
        zoom_end = self.page.console(GetScripts.getZoom)
        self.assertEqual(zoom_end - zoom_start, -1)

    @dataprovider([
        config.aut['local'] + u'/base.html'
    ])
    def zoomIn_dbclick_test(self, url):
        """
        :param url: Адрес страницы
        Проверка зума даблкликом.
        1.Получаем зум страницы
        2.Кликаем в контрол -
        3.Проверяем что зум стал на единицу меньше
        """
        self.driver.get(url)
        self.page.map.wait_init()
        zoom_start = self.page.console(GetScripts.getZoom)
        self.page.map.center_dbclick()
        zoom_end = self.page.console(GetScripts.getZoom)
        self.assertEqual(zoom_end - zoom_start, 1)

    @dataprovider([
        config.aut['local'] + u'/base.html'
    ])
    def zoomIn_shift_select_test(self, url):
        """
        :param url: Адрес страницы
        Проверка зума селектом с shift.
        1.Получаем зум страницы
        2.Выделяем облость с зажатым shift и отпускаем
        3.Проверяем изменение зума
        """
        self.driver.get(url)
        self.page.map.wait_init()
        zoom_start = self.page.console(GetScripts.getZoom)
        self.page.map.zoom_selection()
        zoom_end = self.page.console(GetScripts.getZoom)
        self.assertEqual(zoom_end - zoom_start, 1)


================================================
FILE: gulp/deps/build.html
================================================
<!DOCTYPE html>
<html>
<head>
    <title>Maps API 2.0 Build Helper</title>

    <script type="text/javascript" src="deps.js"></script>

    <script type="text/javascript">
        var buffDeps = deps;
    </script>

    <script type="text/javascript">
        for (var key in buffDeps) {
            deps[key] = buffDeps[key];
        }
    </script>


    <style type="text/css">
        body {
            font: 12px/1.4 Verdana, sans-serif;
            text-align: center;
            padding: 2em 0;
        }

        #container {
            text-align: left;
            margin: 0 auto;
            width: 780px;
        }

        #deplist {
            list-style: none;
            padding: 0;
        }

        #deplist li {
            padding-top: 7px;
            padding-bottom: 7px;
            border-bottom: 1px solid #ddd;
        }

        #deplist li.heading {
            border: none;
            background: #ddd;
            padding: 5px 10px;
            margin-top: 25px;
            border-radius: 5px;
        }

        #deplist input {
            float: left;
            margin-right: 5px;
            display: inline;
        }

        #deplist label {
            float: left;
            width: 160px;
            font-weight: bold;
        }

        #deplist div {
            display: table-cell;
            height: 1%;
        }

        #deplist .desc {
        }

        #deplist .deps {
            color: #777;
        }

        #command,
        #command2 {
            width: 100%;
        }

        #toolbar {
            padding-bottom: 10px;
            border-bottom: 1px solid #ddd;
        }

        h2 {
            margin-top: 2em;
        }
    </style>
</head>
<body>
<div id="container">
    <h1>Maps API 2.0 Build Helper</h1>

    <p id="toolbar">
        <a id="select-all" href="#all">Select All</a> |
        <a id="deselect-all" href="#none">Deselect All</a>
    </p>

    <ul id="deplist"></ul>

    <h2>Building local Maps API 2.0 using Node and Gulp</h2>
    <ol>
        <li><a href="http://nodejs.org/#download">Download and install Node</a></li>
        <li>Run this in the command line:<br/>
			<pre><code>npm install -g gulp
npm install</code></pre>
        </li>
        <li>Run this command inside the app directory: <br/><input type="text" id="command"/>
    </ol>
    <h2>Get URL of custom build Maps API 2.0: </h2>
    <ol>
        <li>URL: <br/><input type="text" id="command2"/></li>
    </ol>
</div>

<script type="text/javascript">
    var deplist = document.getElementById('deplist'),
            commandInput = document.getElementById('command'),
            commandInput2 = document.getElementById('command2');

    document.getElementById('select-all').onclick = function () {
        var checks = deplist.getElementsByTagName('input');
        for (var i = 0; i < checks.length; i++) {
            checks[i].checked = true;
        }
        updateCommand();
        return false;
    };

    document.getElementById('deselect-all').onclick = function () {
        var checks = deplist.getElementsByTagName('input');
        for (var i = 0; i < checks.length; i++) {
            if (!checks[i].disabled) {
                checks[i].checked = false;
            }
        }
        updateCommand();
        return false;
    };

    function updateCommand() {
        var checks = deplist.getElementsByTagName('input');
        var compsStr = '';

        for (var i = 0, len = checks.length; i < len; i++) {
            if (checks[i].checked) {
                if (compsStr === '') {
                    compsStr += checks[i].id;
                } else {
                    compsStr += ',' + checks[i].id;
                }
            }
        }

        commandInput.value = 'gulp build --pkg ' + compsStr;
        commandInput2.value = 'http://maps.api.2gis.ru/2.0/loader.js?pkg=' + compsStr;
    }

    function inputSelect() {
        this.focus();
        this.select();
    }
    ;

    commandInput.onclick = inputSelect;

    function onCheckboxChange() {
        if (this.checked) {
            var depDeps = deps[this.id].deps;
            if (depDeps) {
                for (var i = 0; i < depDeps.length; i++) {
                    var check = document.getElementById(depDeps[i]);
                    if (!check.checked) {
                        check.checked = true;
                        check.onchange();
                    }
                }
            }
        } else {
            var checks = deplist.getElementsByTagName('input');
            for (var i = 0; i < checks.length; i++) {
                var dep = deps[checks[i].id];
                if (!dep.deps) {
                    continue;
                }
                for (var j = 0; j < dep.deps.length; j++) {
                    if (dep.deps[j] === this.id) {
                        if (checks[i].checked) {
                            checks[i].checked = false;
                            checks[i].onchange();
                        }
                    }
                }
            }
        }
        updateCommand();
    }

    for (var name in deps) {
        var li = document.createElement('li');

        if (deps[name].heading) {
            var heading = document.createElement('li');
            heading.className = 'heading';
            heading.appendChild(document.createTextNode(deps[name].heading));
            deplist.appendChild(heading);
        }

        var div = document.createElement('div');

        var label = document.createElement('label');

        var check = document.createElement('input');
        check.type = 'checkbox';
        check.id = name;
        label.appendChild(check);
        check.onchange = onCheckboxChange;

        if (name == 'Core') {
            check.checked = true;
            check.disabled = true;
        }

        label.appendChild(document.createTextNode(name));
        label.htmlFor = name;

        li.appendChild(label);

        var desc = document.createElement('span');
        desc.className = 'desc';
        desc.appendChild(document.createTextNode(deps[name].desc));

        var depText = deps[name].deps && deps[name].deps.join(', ');
        if (depText) {
            var depspan = document.createElement('span');
            depspan.className = 'deps';
            depspan.appendChild(document.createTextNode('Deps: ' + depText));
        }

        div.appendChild(desc);
        div.appendChild(document.createElement('br'));
        if (depText) {
            div.appendChild(depspan);
        }

        li.appendChild(div);

        deplist.appendChild(li);
    }
    updateCommand();
</script>
</body>
</html>


================================================
FILE: gulp/deps/deps.js
================================================
var deps = {
    DGCore: {
        desc: 'Main module',
        src: [
            '../vendors/polyfills/es5.js',
            '../vendors/polyfills/promise.js',
            'DGCore/src/DGCore.js',
            'DGCore/src/DGthen.js',
            'DGCore/src/DGplugin.js'
        ],
        less: {
            all: [
                '../node_modules/leaflet/dist/leaflet.css',
                'DGCore/skin/basic/less/dg-core.less'
            ]
        },
        heading: '2GIS modules'
    },

    DGAjax: {
        desc: '2GIS Ajax module',
        src: ['DGAjax/src/DGAjax.js'],
        deps: ['DGCore']
    },

    DGLabel: {
        desc: '2GIS Label module',
        src: [
            'DGLabel/src/DGLabel.js',
            'DGLabel/src/Marker.DGLabel.js',
            'DGLabel/src/Path.DGLabel.js',
            'DGLabel/src/Entrance.DGLabel.js'
        ],
        less: {
            all: ['DGLabel/skin/{skin}/less/dg-label.less']
        },
        deps: ['DGCore', 'DGEntrance']
    },

    DGWkt: {
        desc: 'WKT parser module',
        src: [
            'DGWkt/DGWkt.js'
        ],
        deps: ['DGCore']
    },

    DGPopup: {
        desc: '2GIS Popup module',
        src: [
            'DGPopup/skin/basic/skin.config.js',
            'DGPopup/src/DGPopup.js'
        ],
        less: {
            all: [
                'DGPopup/skin/{skin}/less/leaflet.less',
                '../vendors/baron/baron.css',
                'DGPopup/skin/{skin}/less/scroller.less',
                'DGPopup/skin/{skin}/less/dg-popup.less'
            ],
            ie: [
                'DGPopup/skin/{skin}/less/leaflet.ie.less',
                'DGPopup/skin/{skin}/less/dg-popup.ie.less'
            ]
        },
        deps: ['DGCore']
    },

    DGCustomization: {
        desc: 'LeafLet customization module',
        src: [
            'DGCustomization/skin/basic/skin.config.js',
            'DGCustomization/src/DGCustomization.js',
            'DGCustomization/src/DGMap.js',
            'DGCustomization/src/DGMap.BaseLayer.js',
            'DGCustomization/src/DGMap.ApiKeyValidator.js',
            'DGCustomization/src/DGMap.TilesCheck.js',
            'DGCustomization/src/DGMap.Drag.js',
            'DGCustomization/src/DGPolyUtil.js',
            'DGCustomization/src/DGMobileImprove.js'
        ],
        less: {
            all: [
                'DGCustomization/skin/{skin}/less/leaflet.less',
                '../vendors/baron/baron.css',
                'DGCustomization/skin/{skin}/less/scroller.less',
                'DGCustomization/skin/{skin}/less/dg-customization.less'
            ],
            ie: [
                'DGCustomization/skin/{skin}/less/leaflet.ie.less',
                'DGCustomization/skin/{skin}/less/dg-customization.ie.less'
            ]
        },
        deps: ['DGCore', 'DGLocale', 'DGRoundControl', 'DGProjectDetector', 'DGMuseum']
    },

    DGZoomControl: {
        desc: '2GIS zoom control module',
        src: [
            'DGZoomControl/src/DGZoomControl.js',
            'DGZoomControl/lang/ru.js',
            'DGZoomControl/lang/it.js',
            'DGZoomControl/lang/cs.js',
            'DGZoomControl/lang/en.js',
            'DGZoomControl/lang/es.js',
            'DGZoomControl/lang/ar.js'
        ],
        less: {
            all: [
                'DGZoomControl/skin/{skin}/less/dg-zoom-control.less'
            ]
        },
        deps: ['DGCore', 'DGLocale', 'DGRoundControl']
    },

    DGAttribution: {
        desc: '2GIS copyright',
        src: [
            'DGAttribution/src/DGAttribution.js',
            'DGAttribution/lang/ru.js',
            'DGAttribution/lang/it.js',
            'DGAttribution/lang/cs.js',
            'DGAttribution/lang/en.js',
            'DGAttribution/lang/es.js',
            'DGAttribution/lang/ar.js'
        ],
        less: {
            all: [
                'DGAttribution/skin/{skin}/less/dg-mapcopyright.less'
            ]
        },
        deps: ['DGCore', 'DGDust', 'DGLocale']
    },

    DGLocale: {
        desc: 'Localization module',
        src: [
            'DGLocale/src/DGDictionary.js',
            'DGLocale/src/DGLocale.js'
        ],
        deps: ['DGCore', 'DGProjectDetector']
    },

    DGLocation: {
        desc: 'Location control module',
        src: [
            'DGLocation/src/DGLocation.js',
            'DGLocation/lang/ru.js',
            'DGLocation/lang/it.js',
            'DGLocation/lang/cs.js',
            'DGLocation/lang/en.js',
            'DGLocation/lang/es.js',
            'DGLocation/lang/ar.js'
        ],
        less: {
            all: [
                'DGLocation/skin/{skin}/less/dg-location.less',
                'DGLocation/skin/{skin}/less/dg-control-round.less'
            ]
        },
        deps: ['DGCore', 'DGLocale', 'DGLabel', 'DGRoundControl']
    },

    DGFullScreen: {
        desc: 'Full screen module',
        src: [
            'DGFullScreen/src/DGScreenfull.js',
            'DGFullScreen/src/DGFullScreen.js',
            'DGFullScreen/lang/ru.js',
            'DGFullScreen/lang/it.js',
            'DGFullScreen/lang/cs.js',
            'DGFullScreen/lang/en.js',
            'DGFullScreen/lang/es.js',
            'DGFullScreen/lang/ar.js'
        ],
        less: {
            all: [
                'DGFullScreen/skin/{skin}/less/dg-fullscreen.less',
                'DGFullScreen/skin/{skin}/less/dg-control-round.less'
            ],
            ie: ['DGFullScreen/skin/{skin}/less/dg-fullscreen.ie.less']
        },
        deps: ['DGCore', 'DGLocale', 'DGRoundControl']
    },

    DGProjectDetector: {
        desc: '2GIS project detector module',
        src: ['DGProjectDetector/src/DGProjectDetector.js'],
        deps: ['DGCore', 'DGWkt']
    },

    DGMeta: {
        desc: '2GIS additional metalayers support',
        src: [
            'DGMeta/src/DGMeta.Layer.js',
            'DGMeta/src/DGMeta.Origin.js'
        ],
        deps: ['DGAjax', 'DGCore', 'DGCustomization', 'DGWkt', 'DGProjectDetector']
    },

    DGPoi: {
        desc: '2GIS POI module',
        src: ['DGPoi/src/DGPoi.js'],
        deps: ['DGMeta', 'DGLabel']
    },

    DGGeoclicker: {
        desc: '2GIS Geoclicker',
        less: {
            all: [
                'DGGeoclicker/skin/{skin}/less/dg-building-callout.less',
                'DGGeoclicker/skin/{skin}/less/dg-map-geoclicker.less',
                'DGGeoclicker/skin/{skin}/less/dg-preloader.less',
                'DGGeoclicker/skin/{skin}/less/dg-popup.less',
                'DGGeoclicker/skin/{skin}/less/dg-firm-card.less',
                'DGGeoclicker/skin/{skin}/less/dg-schedule.less',
                'DGGeoclicker/skin/{skin}/less/dg-link.less'
            ],
            ie: [
                'DGGeoclicker/skin/{skin}/less/dg-popup.ie.less',
                'DGGeoclicker/skin/{skin}/less/dg-schedule.ie.less'
            ]
        },
        src: [
            'DGGeoclicker/src/DGGeoclicker.js',
            'DGGeoclicker/src/ClampHelper.js',
            'DGGeoclicker/src/provider/Provider.js',
            'DGGeoclicker/src/provider/CatalogApi.js',
            'DGGeoclicker/src/handler/Handler.js',
            'DGGeoclicker/src/handler/Default.js',
            'DGGeoclicker/src/handler/ApiError.js',
            'DGGeoclicker/src/handler/CityArea.js',
            'DGGeoclicker/src/handler/House.js',
            'DGGeoclicker/src/handler/House.View.js',
            'DGGeoclicker/src/handler/POI.js',
            'DGGeoclicker/src/handler/Sight.js',
            'DGGeoclicker/src/View.js',
            'DGGeoclicker/src/Controller.js',
            'DGGeoclicker/lang/it.js',
            'DGGeoclicker/lang/ru.js',
            'DGGeoclicker/lang/en.js',
            'DGGeoclicker/lang/cs.js',
            'DGGeoclicker/lang/es.js',

            '../vendors/firmcard/src/FirmCard.js',
            '../vendors/firmcard/src/FirmCard.DataHelper.js',
            '../vendors/firmcard/src/FirmList.js',
            '../vendors/firmcard/src/Schedule.js',
            '../vendors/firmcard/src/Dictionary.js'
        ],
        deps: ['DGAjax', 'DGCore', 'DGDust', 'DGLocale', 'DGPoi', 'DGEntrance', 'DGProjectDetector', 'DGPopup']
    },

    DGDust: {
        desc: '2GIS Template',
        src: [
            'DGDust/src/DGDust.js'
        ],
        deps: ['DGCore']
    },

    DGEntrance: {
        desc: '2GIS Entrances',
        src: [
            'DGEntrance/src/DGMetric.js',
            'DGEntrance/src/DGVertexTransform.js',
            'DGEntrance/src/DGArrowPathTransform.js',
            'DGEntrance/src/DGArrowTipTransform.js',
            'DGEntrance/src/DGComplexPath.js',
            'DGEntrance/src/DGRenderer.js',
            'DGEntrance/src/DGBezierCurves.js',
            'DGEntrance/src/DGAnimation.js',
            'DGEntrance/src/DGEntrance.js',
            'DGEntrance/src/DGEntranceArrow.js',
            'DGEntrance/src/DGEntranceArrowShape.js'
        ],
        deps: ['DGCore', 'DGWkt', 'DGProjectDetector']
    },


    DGRoundControl: {
        desc: 'Control helper',
        src: ['DGRoundControl/src/DGRoundControl.js'],
        less: {
            all: ['DGRoundControl/skin/{skin}/less/dg-control-round.less']
        },
        deps: ['DGCore', 'DGLocale']
    },

    DGTraffic: {
        desc: 'Traffic',
        src: [
            'DGTraffic/src/DGTraffic.js',
            'DGTraffic/lang/ru.js',
            'DGTraffic/lang/it.js',
            'DGTraffic/lang/cs.js',
            'DGTraffic/lang/es.js',
            'DGTraffic/lang/en.js',
            'DGTraffic/lang/ar.js'
        ],
        deps: ['DGMeta', 'DGLabel', 'DGLocale']
    },

    DGTrafficControl: {
        desc: 'Traffic control module',
        src: [
            'DGTrafficControl/src/Control.Traffic.js',
            'DGTrafficControl/lang/ru.js',
            'DGTrafficControl/lang/it.js',
            'DGTrafficControl/lang/cs.js',
            'DGTrafficControl/lang/es.js',
            'DGTrafficControl/lang/en.js',
            'DGTrafficControl/lang/ar.js'
        ],
        less: {
            all: [
                'DGTrafficControl/skin/{skin}/less/dg-control-round.less',
                'DGTrafficControl/skin/{skin}/less/dg-traffic-control.less'
            ],
            ie: ['DGTrafficControl/skin/{skin}/less/dg-traffic-control.ie.less']
        },
        deps: ['DGTraffic', 'DGRoundControl']
    },

    DGRuler: {
        desc: 'Ruler module',
        src: [
            'DGRuler/src/Ruler.js',
            'DGRuler/src/LayeredMarker.js',
            'DGRuler/src/GeometryStyles.js',
            'DGRuler/lang/ru.js',
            'DGRuler/lang/it.js',
            'DGRuler/lang/cs.js',
            'DGRuler/lang/es.js',
            'DGRuler/lang/en.js',
            'DGRuler/lang/ar.js'
        ],
        less: {
            all: ['DGRuler/skin/{skin}/less/dg-ruler.less'],
            ie: ['DGRuler/skin/{skin}/less/dg-ruler.ie.less']
        },
        deps: ['DGCore', 'DGLocale']
    },

    DGRulerControl: {
        desc: 'Ruler control module',
        src: [
            'DGRulerControl/src/Control.Ruler.js',
            'DGRulerControl/lang/ru.js',
            'DGRulerControl/lang/it.js',
            'DGRulerControl/lang/cs.js',
            'DGRulerControl/lang/es.js',
            'DGRulerControl/lang/en.js',
            'DGRulerControl/lang/ar.js'
        ],
        less: {
            all: ['DGRulerControl/skin/{skin}/less/dg-control-round.less']
        },
        deps: ['DGRuler', 'DGRoundControl']
    },

    DGMuseum: {
        desc: 'Museum module',
        src: [
            'DGMuseum/src/DGMuseum.js'
        ],
        less: {
            all: ['DGMuseum/skin/{skin}/less/dg-museum.less']
        }
    }
};

if (typeof module !== 'undefined' && module.exports) {
    module.exports = deps;
}


================================================
FILE: gulp/deps/index.js
================================================
var fs = require('fs');
var glob = require('glob');
var path = require('path');
var imageSize = require('image-size');

var init = function(config) {
    var packages = config.packages;

    // Generates a list of modules by pkg
    function getModulesList(pkg, modules, isLeaflet) { //(String|Null)->Array
        modules = modules || config.source.deps;

        var modulesListOrig = [];
        var modulesListRes = [];
        var loadedModules = {};

        if (typeof pkg === 'boolean') {
            throw new Error('pkg param can\'t be empty');
        }

        // Package name with no empty modules list on packs.js (example: 'base')
        if (pkg && pkg in packages && packages[pkg].modules.length > 0) {
            modulesListOrig = packages[pkg].modules;

            // Modules list (example: 'Core,JSONP,TileLayer')
        } else if (pkg && pkg.indexOf(',') !== -1) {
            modulesListOrig = pkg.split(',');

            // Modules single (example: 'Core')
        } else if (pkg && pkg in modules) {
            modulesListOrig.push(pkg);

            // Others (null / full package)
        } else {
            modulesListOrig = modulesListOrig.concat(Object.keys(modules));
        }

        if (!isLeaflet) {
            modulesListOrig = modulesListOrig.concat(config.coreModules);
        }

        function processModule(name) {
            var module = modules[name];

            if (module && module.deps) {
                module.deps.forEach(processModule);
            }

            if (!loadedModules[name]) {
                modulesListRes.push(name);
                loadedModules[name] = true;
            }
        }

        modulesListOrig.forEach(processModule);

        return modulesListRes;
    }

    function getJSFiles(options) {
        options = options || {};

        var source = config[options.source || 'source'];
        var modules = source.deps;
        var sourcePath = source.path;
        var isLeaflet = options.source === 'leaflet';

        return getModulesList(options.pkg, modules, isLeaflet)
            .map(function(name) {
                return modules[name];
            })
            .map(function(module) {
                return module.src;
            })
            .reduce(function(array, items) {
                return array.concat(items);
            })
            .filter(function(item, index, list) { //filter dublicates
                return list.indexOf(item) == index;
            })
            .map(function(file) {
                return sourcePath + file;
            });
    }

    function getCSSFiles(options) {
        options = options || {};

        var source = config[options.source || 'source'];
        var modules = source.deps;
        var sourcePath = source.path;
        var skin = options.skin || config.appConfig.defaultSkin;

        return getModulesList(options.pkg, modules)
            .map(function(name) {
                return modules[name];
            })
            .map(function(module) {
                return module[options.type || 'less'];
            })
            .filter(Boolean)
            .reduce(function(array, item) {
                var items = [];

                if (!options.excludeBaseCss && item.all) {
                    items.push(item.all);
                }

                if (options.ie8 && item.ie) {
                    items.push(item.ie);
                }

                return array.concat(items);
            }, [])
            .reduce(function(array, items) {
                return array.concat(items);
            }, [])
            .reduce(function(array, item) { // if css have skin, we add basic theme
                if (item.indexOf('{skin}') !== -1) {
                    array.push(item.replace('{skin}', 'basic'));
                }

                return array.concat(item);
            }, [])
            .map(function(file) { // add selected theme
                return file.replace('{skin}', skin);
            })
            .map(function(file) {
                return sourcePath + file;
            })
            .filter(fs.existsSync);
    }

    function getImgGlob(options) {
        options = options || {};

        var source = config[options.source || 'source'];
        var modules = source.deps;

        return getModulesList(options.pkg, modules)
            .map(function(name) {
                return 'src/' + name + '/**/img/**/*.{png,gif,jpg,jpeg,svg}';
            });
    }

    // Build string with Less variables and imports
    function lessHeader(options) {
        options = options || {};

        var header = '';

        if (options.variables) {
            Object.keys(options.variables).forEach(function(varableName) {
                header = header + '\n' + '@' + varableName + ': ' + options.variables[varableName] + ';';
            });
        }

        var importsBase = '';

        if (typeof options.importsBase === 'string' && options.importsBase.length) {
            importsBase = options.importsBase.replace(/\/*$/, '/');
        }

        if (options.imports) {
            for (var i = 0, type = '', imoportPath = ''; i < options.imports.length; i++) {
                type = options.imports[i].replace(/^.*\:/, '');
                imoportPath = options.imports[i].replace(/\:.*$/, '');

                header = header + '\n' + '@import (' + type + ') \'' + importsBase + imoportPath + '\';';
            }
        }

        return header;
    }

    // Scans the project for skins directories to get skins names
    function getSkinsList() {
        var skinsDirectories = glob.sync(__dirname + '/../../src/**/skin/*');
        var skins = [];

        skinsDirectories.forEach(function(directory) {
            var skinName = path.basename(directory);

            if (skins.indexOf(skinName) === -1) {
                skins.push(skinName);
            }
        });

        return skins;
    }

    // Gets images per skin formats statistics
    function getImagesFilesStats(skins) {
        skins = skins || getSkinsList();

        var perSkinStats = {};
        var imgModulesGlobs = getImgGlob();

        imgModulesGlobs.forEach(function(imgGlob) {
            glob.sync(imgGlob).forEach(function(imagePath) {
                var skinName = imagePath.split('/')[3];
                var extname = path.extname(imagePath);
                var name = path.basename(imagePath, extname);
                var imageDimensions;

                if (skins.indexOf(skinName) === -1) {
                    return; // continue
                }

                if (!(skinName in perSkinStats)) {
                    perSkinStats[skinName] = {};
                }

                if (!(name in perSkinStats[skinName])) {
                    perSkinStats[skinName][name] = {};
                }

                if (extname === '.svg') {
                    perSkinStats[skinName][name].hasVectorVersion = true;
                } else {
                    perSkinStats[skinName][name].extension = extname.replace('.', '');

                    imageDimensions = imageSize(imagePath);

                    perSkinStats[skinName][name].width = imageDimensions.width;
                    perSkinStats[skinName][name].height = imageDimensions.height;
                }
            });
        });

        return perSkinStats;
    }

    // Analyzes Less, gets images usage statistics per skin
    function getImagesUsageStats(skins) {
        skins = skins || getSkinsList();

        var perSkinStats = {};

        skins.forEach(function(skinName) {
            var stats = {};

            var statsFilePath = __dirname + '/../tmp/less/images-usage-statistics.' + skinName + '.less';
            var statsFileContent = fs.readFileSync(statsFilePath).toString();
            var preparedStatsFileContent = statsFileContent.slice(6).replace(/\;/g, ','); // 6 is 'stats '.length

            var rawStats = Function('return ' + preparedStatsFileContent + ';')();

            stats.repeatable = rawStats.repeatable.split(',');
            stats.notRepeatableSprited = rawStats.notRepeatableSprited.split(',');
            stats.notRepeatableNotSprited = rawStats.notRepeatableNotSprited.split(',');
            // Repeatable images can be used as no-repeatable images,
            // so we should exclude repeatable images from no-repeatable images list
            stats.notRepeatableSprited = rawStats.notRepeatableSprited.split(',').filter(function(name) {
                return stats.repeatable.indexOf(name) === -1;
            });

            perSkinStats[skinName] = stats;
        });

        return perSkinStats;
    }

    return {
        getModulesList: getModulesList,

        getJSFiles: getJSFiles,
        getCSSFiles: getCSSFiles,

        lessHeader: lessHeader,

        getSkinsList: getSkinsList,

        getImagesFilesStats: getImagesFilesStats,
        getImagesUsageStats: getImagesUsageStats,

        getImgGlob: getImgGlob
    };
};


if (typeof module !== 'undefined' && module.exports) {
    module.exports = init;
}


================================================
FILE: gulp/deps/packs.js
================================================
var packages = {

    basic: {
        name: 'Basic package',
        desc: 'Provides basic functionality: map, markers, popups, geometries',
        modules: ['DGCustomization', 'DGFullScreen', 'DGAttribution', 'DGAjax', 'DGPopup', 'DGZoomControl']
    },

    full: {
        name: 'Full package',
        desc: 'Complete package. Includes all the features of 2GIS Maps API',
        modules: []
    }

};

if (typeof module !== 'undefined' && module.exports) {
    module.exports = packages;
}


================================================
FILE: gulp/sprite-template.mustache
================================================

{{#items}}
.spriteData('{{name}}') {
    @backgroundImage: '{{{escaped_image}}}';
    @backgroundPosition: {{px.offset_x}} {{px.offset_y}};
    @backgroundPositionLeft: {{px.offset_x}};
    @backgroundPositionTop: {{px.offset_y}};
    @width: {{px.width}};
    @height: {{px.height}};
    @totalWidth: {{px.total_width}};
    @totalHeight: {{px.total_height}};
    }

.isSprited(@name) when (@name = '{{name}}') {
    @isSprited: true;
    }

{{/items}}


================================================
FILE: gulp/tasks/build.js
================================================
var { buildEnd } = require('../util/buildEnd.js');
var config = require('../../app/config.js');
var argv = require('minimist')(process.argv.slice(2));
var gulp = require('gulp');
var { clean } = require('./clean');
var { buildStyles } = require('./buildStyles');
var { buildScripts } = require('./buildScripts');
var { doc } = require('./doc');
var { loader } = require('./loader');
var { copyAssets } = require('./copyAssets');
var { copyIndexPage } = require('./copyIndexPage');

function npmConfigModify(done) {
    if (argv.npm) {
        // Disable local config for npm builds
        config.appConfig = config.mainConfig;

        // Make npm builds https-only
        config.appConfig.protocol = 'https:';
    }
    done();
}

exports.build = gulp.series(npmConfigModify, clean, buildStyles, gulp.parallel(
    buildScripts,
    doc,
    loader,
    copyAssets,
    copyIndexPage
), buildEnd);


================================================
FILE: gulp/tasks/buildLeaflet.js
================================================
var concat = require('gulp-concat');
var gulp = require('gulp');
var log = require('fancy-log');
var argv = require('minimist')(process.argv.slice(2));
var path = require('path');

var config = require('../../app/config.js');
var deps = require('../deps')(config);

function getLeafletFiles(compsBase32) {
    var memo = {},
        deps = require('leaflet/build/deps.js').deps,
        comps;

    if (compsBase32) {
        comps = parseInt(compsBase32, 32).toString(2).split('');
        log('Managing dependencies...');
    }

    function addFiles(srcs) {
        for (var j = 0, len = srcs.length; j < len; j++) {
            memo[srcs[j]] = true;
        }
    }

    for (var i in deps) {
        if (comps) {
            if (parseInt(comps.pop(), 2) === 1) {
                log(' * ' + i);
                addFiles(deps[i].src);
            } else {
                log('   ' + i);
            }
        } else {
            addFiles(deps[i].src);
        }
    }

    log('\n');

    var files = [];

    for (var src in memo) {
        files.push('src/' + src);
    }

    return files;
}

// leaflet-custom-build parameter for set id of leaflet build. See more in leaflet/build/build.html
exports.buildLeaflet = function buildLeaflet() {
    var leafletCustomBuild = argv['leaflet-custom-build'];
    return (leafletCustomBuild ? gulp.src(getLeafletFiles(leafletCustomBuild).map(function (file) {
        return path.resolve(path.join(__dirname, '../../node_modules/leaflet/', file))
    })) : gulp.src(deps.getJSFiles({source: 'leaflet'})))
        .pipe(concat('leaflet-src.js'))
        .pipe(gulp.dest('node_modules/leaflet/dist/'));
};


================================================
FILE: gulp/tasks/buildScripts.js
================================================
var config = require('../../app/config.js');
var stat = require('../util/stat');
var source = require('vinyl-source-stream');
var derequire = require('gulp-derequire');
var browserify = require('browserify');
var buffer = require('vinyl-buffer');
var uglify = require('gulp-uglify');
var header = require('gulp-header');
var mergeStream = require('merge-stream');
var gulpif = require('gulp-if');
var argv = require('minimist')(process.argv.slice(2));
var gulp = require('gulp');
var path = require('path');
var map = require('map-stream');
var insert = require('gulp-insert');
var sourcemaps = require('gulp-sourcemaps');
var { concatScripts } = require('./concatScripts');

function buildScripts() {
    var isCustom = argv.pkg || argv.skin;
    var packages;

    if (global.isTestBuild) {
        packages = ['full'];
    } else if (isCustom) {
        packages = [argv.pkg || 'full'];
    } else {
        packages = Object.keys(config.packages);
    }

    return mergeStream(packages.map(function(pkg) {
        var name = 'script.' + (!isCustom ? pkg + '.' : '') + 'js';
        var src = path.join('gulp', 'tmp', 'js', name);

        var bundler = browserify(src, {
            debug: !argv.release,
            entry: true,
            standalone: argv.npm ? 'DG': false,
            cache: {},
            packageCache: {},
            sourceMaps: argv.release
        });

        bundler.transform('browserify-css', {
            autoInject: true,
            minify: true
        });

        return bundler.bundle()
            .pipe(source(name))
            .pipe(buffer())
            .pipe(derequire())
            .pipe(gulpif(argv.release, sourcemaps.init()))
            .pipe(gulpif(argv.release, uglify()))
            .pipe(gulpif(argv.release, header(config.copyright)))
            .pipe(gulpif(
                Boolean(argv['leaflet-custom-build']),
                insert.prepend('// leaflet-custom-build: ' + argv['leaflet-custom-build'] + '\n')
            ))
            .pipe(gulpif(argv.release, sourcemaps.write('./')))
            .pipe(map(stat.save))
            .pipe(gulp.dest('dist/js/'));
    }));
}

exports.buildScripts = gulp.series(concatScripts, buildScripts);


================================================
FILE: gulp/tasks/buildStyles.js
================================================
var gulp = require('gulp');

var { destCSS } = require('../util/destCSS');
var { collectImagesStats } = require('./collectImagesStats');
var { generateSprites } = require('./generateSprites');
var { imageMinify } = require('./imageMinify');

exports.buildStyles = gulp.series(gulp.parallel(
    collectImagesStats,
    generateSprites,
    imageMinify
), destCSS);


================================================
FILE: gulp/tasks/buildTest.js
================================================
var gulp = require('gulp');

var { buildEnd } = require('../util/buildEnd.js');
var { buildStyles } = require('./buildStyles');
var { buildScripts } = require('./buildScripts');
var { doc } = require('./doc');
var { clean } = require('./clean');
var { loader } = require('./loader');
var { copyAssets } = require('./copyAssets');
var { copyIndexPage } = require('./copyIndexPage');

function enableTestBuild(done) {
    global.isTestBuild = true;
    done();
}

exports.buildTest = gulp.series(enableTestBuild, clean, gulp.parallel(
    buildScripts,
    buildStyles,
    doc,
    loader,
    copyAssets,
    copyIndexPage
), buildEnd);


================================================
FILE: gulp/tasks/clean.js
================================================
var del = require('del');

exports.clean = function clean() {
    return del(['dist', 'gulp/tmp']);
};


================================================
FILE: gulp/tasks/collectImagesStats.js
================================================
var gulp = require('gulp');
var fs = require('fs');
var mkdirp = require('mkdirp');

var config = require('../../app/config');
var deps = require('../deps')(config);
var { copyImg } = require('./copyImg');

function collectImagesStats(cb) {
    var skins = deps.getSkinsList();
    var imagesStatsPerSkin = deps.getImagesFilesStats(skins);

    mkdirp.sync('./gulp/tmp');
    mkdirp.sync('./gulp/tmp/less');

    skins.forEach(function(skinName) {
        var skinImagesFilesStats = imagesStatsPerSkin[skinName];

        var statisticsObject;
        var statisticsString = '';

        var imageExtension;

        var originalImageName;
        var originalImageStatisticObject;

        for (var imageName in skinImagesFilesStats) {
            originalImageName = imageName.replace(/@\d+(\.\d+)?x/, '');

            statisticsObject = skinImagesFilesStats[imageName];
            originalImageStatisticObject = skinImagesFilesStats[originalImageName];

            imageExtension = (typeof statisticsObject.extension === 'undefined') ? 'svg' : statisticsObject.extension;

            statisticsString += '.imageData(\'' + imageName + '\') { ' +
                '@filename: \'' + imageName + '\'; ' +
                '@extension: \'' + imageExtension + '\'; ' +
                '@hasVectorVersion: ' + !!statisticsObject.hasVectorVersion + '; ' +
                '@width: ' + statisticsObject.width + 'px; ' +
                '@height: ' + statisticsObject.height + 'px; ' +
                '@originalWidth: ' + originalImageStatisticObject.width + 'px; ' +
                '@originalHeight: ' + originalImageStatisticObject.height + 'px; ' +
                '}\n';
        }

        fs.writeFileSync('./gulp/tmp/less/images-files-statistics.' + skinName + '.less', statisticsString);
    });

    cb();
}

exports.collectImagesStats = gulp.series(copyImg, collectImagesStats);


================================================
FILE: gulp/tasks/collectImagesUsageStats.js
================================================
var header = require('gulp-header');
var rename = require('gulp-rename');
var mergeStream = require('merge-stream');
var less = require('gulp-less');
var gulp = require('gulp');
var path = require('path');
var glob = require('glob');

var error = require('../util/error');
var config = require('../../app/config');
var deps = require('../deps')(config);

exports.collectImagesUsageStats = function collectImagesUsageStats() {
    var skins = deps.getSkinsList();

    var imagesBasePath = path.resolve(__dirname + '/../../dist/img');

    var statisticsStreams = skins.map(function(skinName) {
        var skinLessFiles = glob.sync('./src/**/' + skinName + '/less/*.less');

        skinLessFiles.unshift('./src/less/mixins.images-usage-statistics.less');
        skinLessFiles.unshift('./src/less/mixins.ie8.less');

        skinLessFiles = skinLessFiles.map(function(lessFilePath) {
            return lessFilePath + ':reference';
        });

        return gulp.src('src/less/images-usage-statistics.less')
            .pipe(error.handle())
            .pipe(header(deps.lessHeader({
                variables: {
                    baseURL: '\'__BASE_URL__\'',
                    spritesURL: '\'__BASE_URL__\'',

                    ie8: true,
                    useSprites: true,
                    mobile: false,
                    retina: false,

                    skinName: skinName,

                    imagesBasePath: '\'' + imagesBasePath + '\''
                },
                imports: skinLessFiles
            })))
            .pipe(less())
            .pipe(rename('images-usage-statistics.' + skinName + '.less'))
            .pipe(gulp.dest('gulp/tmp/less/'));
    });

    return mergeStream(statisticsStreams);
};


================================================
FILE: gulp/tasks/concatScripts.js
================================================
var sourcemaps = require('gulp-sourcemaps');
var streamqueue = require('streamqueue');
var concat = require('gulp-concat');
var footer = require('gulp-footer');
var mergeStream = require('merge-stream');
var gulpif = require('gulp-if');
var argv = require('minimist')(process.argv.slice(2));
var gulp = require('gulp');

var config = require('../../app/config.js');
var deps = require('../deps')(config);

var templateStream = require('../util/templateStream');
var projectList = require('../util/projectList');
var error = require('../util/error');
var { loadProjectList } = require('./loadProjectList');
var { buildLeaflet } = require('./buildLeaflet');

function getStyleRequireStatement(pack, skin) {
    return 'require("../../../dist/css/styles.' + pack + '.' + skin + '.css");';
}

function concatScripts() {
    var isCustom = argv.pkg || argv.skin;
    var packages;

    if (global.isTestBuild) {
        packages = ['full'];
    } else if (isCustom) {
        packages = [argv.pkg || 'full'];
    } else {
        packages = Object.keys(config.packages);
    }

    if (global.isTestBuild) {
        // Disable tile loading in test build
        config.appConfig.tileServer = '';
    }

    return mergeStream(packages.map(function(pkg) {
        var stream = streamqueue(
                {objectMode: true},
                gulp.src(deps.getJSFiles({pkg: pkg}), {base: '.'}),
                templateStream(pkg)
            )
            .pipe(error.handle())
            .pipe(gulpif(!argv.release, sourcemaps.init()))
            .pipe(concat('script.' + (!isCustom ? pkg + '.' : '') + 'js'))
            .pipe(footer(projectList.get()))
            .pipe(footer('DG.config = ' + JSON.stringify(config.appConfig) + ';'));

        if (argv.npm) {
            stream = stream.pipe(footer(getStyleRequireStatement(pkg, 'dark')));
        }

        return stream
            .pipe(gulpif(!argv.release, sourcemaps.write()))
            .pipe(gulp.dest('gulp/tmp/js'));
    }));
}

const projectListTask = argv['project-list'] !== false ? [loadProjectList] : [];

exports.concatScripts = gulp.series(gulp.parallel(
    ...projectListTask,
    buildLeaflet
), concatScripts);


================================================
FILE: gulp/tasks/copyAssets.js
================================================
var gulp = require('gulp');
var error = require('../util/error');

exports.copyAssets = function copyAssets() {
    return gulp.src(['assets/**/*'])
        .pipe(error.handle())
        .pipe(gulp.dest('dist'));
};


================================================
FILE: gulp/tasks/copyImg.js
================================================
var rename = require('gulp-rename');
var argv = require('minimist')(process.argv.slice(2));
var gulp = require('gulp');

var error = require('../util/error');
var config = require('../../app/config');
var deps = require('../deps')(config);

exports.copyImg = function copyImg() {
    return gulp.src(deps.getImgGlob(argv))
        .pipe(error.handle())
        .pipe(rename(function(p) {
            p.dirname = '';
        }))
        .pipe(gulp.dest('dist/img'));
};


================================================
FILE: gulp/tasks/copyIndexPage.js
================================================
var gulp = require('gulp');
var error = require('../util/error');

exports.copyIndexPage = function copyIndexPage() {
    return gulp.src(['app/index.html'])
        .pipe(error.handle())
        .pipe(gulp.dest('dist'));
};


================================================
FILE: gulp/tasks/dev.js
================================================
var gulp = require('gulp');
var { build } = require('./build');
var { server } = require('./server');
var { watch } = require('./watch');

exports.dev = gulp.series(build, server, watch);


================================================
FILE: gulp/tasks/doc.js
================================================
var gendoc = require('../util/gendoc');
var config = require('../../app/config');

exports.doc = function doc(done) {
    var doc = config.doc;

    gendoc.generateDocumentation(doc.menu, doc.input, doc.output);
    done();
};


================================================
FILE: gulp/tasks/generateSprites.js
================================================
var spritesmith = require('gulp.spritesmith');
var mergeStream = require('merge-stream');
var gulp = require('gulp');

var error = require('../util/error');
var config = require('../../app/config');
var deps = require('../deps')(config);
var { collectImagesUsageStats } = require('./collectImagesUsageStats');

function generateSprites() {
    var skins = deps.getSkinsList();
    var stats = deps.getImagesUsageStats(skins);

    var statisticsStreams = skins.map(function(skinName) {
        // Adds comma to make glob’s {} working properly,
        // even there is only one should be excluded
        var filesToExclude = stats[skinName].repeatable.join(',') + ',' +
            stats[skinName].notRepeatableNotSprited.join(',');

        var pngList = [
            'src/**/' + skinName + '/img/**/*.png',
            '!src/**/' + skinName + '/img/**/*@2x.png',
            '!src/**/' + skinName + '/img/**/{' + filesToExclude + '}.png'
        ];
        var png2xList = [
            'src/**/' + skinName + '/img/**/*@2x.png',
            '!src/**/' + skinName + '/img/**/{' + filesToExclude + '}@2x.png'
        ];
        var spriteData = gulp.src(pngList)
            .pipe(error.handle())
            .pipe(spritesmith({
                cssTemplate: 'gulp/sprite-template.mustache',
                imgName: 'sprite.' + skinName + '.png',
                cssName: 'sprite.' + skinName + '.less',
                engine: 'pixelsmith'
            }));
        var spriteData2x = gulp.src(png2xList)
            .pipe(error.handle())
            .pipe(spritesmith({
                cssTemplate: 'gulp/sprite-template.mustache',
                //padding: 1, // генерирует неправильные смещения :(
                imgName: 'sprite@2x.' + skinName + '.png',
                cssName: 'sprite@2x.' + skinName + '.less',
                engine: 'pixelsmith'
            }));

        return mergeStream(
            spriteData.img
                .pipe(gulp.dest('dist/img/')),

            spriteData2x.img
                .pipe(gulp.dest('dist/img/')),

            spriteData.css
                .pipe(gulp.dest('gulp/tmp/less/')),

            spriteData2x.css
                .pipe(gulp.dest('gulp/tmp/less/'))
        );
    });

    return mergeStream(statisticsStreams);
}

exports.generateSprites = gulp.series(collectImagesUsageStats, generateSprites);


================================================
FILE: gulp/tasks/imageMinify.js
================================================
var imagemin = require('gulp-imagemin');
var argv = require('minimist')(process.argv.slice(2));
var gulpif = require('gulp-if');
var gulp = require('gulp');
var { copyAssets } = require('./copyAssets');
var { copyImg } = require('./copyImg');
var { generateSprites } = require('./generateSprites');

function imageMinify() {
    return gulp.src('dist/img/**/*.{png,gif,jpg,jpeg}')
        .pipe(gulpif(argv.release, imagemin()))
        .pipe(gulp.dest('dist/img'));
}

exports.imageMinify = gulp.series(
    gulp.parallel(
        copyAssets,
        copyImg,
        generateSprites
    ),
    imageMinify,
);


================================================
FILE: gulp/tasks/lint.js
================================================
var gulp = require('gulp');
var { lintJS } = require('./lintJS');
var { lintCSS } = require('./lintCSS');

exports.lint = gulp.parallel(lintJS, lintCSS);


================================================
FILE: gulp/tasks/lintCSS.js
================================================
var gulp = require('gulp');

var csslint = require('../util/csslint/gulp-csslint');
var error = require('../util/error');
var {buildStyles} = require('./buildStyles');

function lintCSS() {
    return gulp.src('dist/css/**.css')
        .pipe(error.handle())
        .pipe(csslint({
            'adjoining-classes': false,
            'box-model': false,
            'box-sizing': false,
            'compatible-vendor-prefixes': false,
            'empty-rules': false,
            'display-property-grouping': false,
            'duplicate-background-images': false,
            'fallback-colors': false,
            'font-sizes': false,
            'gradients': false,
            'important': false,
            'overqualified-elements': false,
            'outline-none': false,
            'regex-selectors': false,
            'vendor-prefix': false,
            'unqualified-attributes': false,
            'zero-units': false
        }))
        .pipe(csslint.reporter());
}

exports.lintCSS = gulp.series(buildStyles, lintCSS);


================================================
FILE: gulp/tasks/lintJS.js
================================================
var eslint = require('gulp-eslint');
var gulp = require('gulp');

var error = require('../util/error');

exports.lintJS = function lintJS() {
    return gulp.src('src/**/src/**/*.js')
        .pipe(error.handle())
        .pipe(eslint())
        .pipe(eslint.format())
        .pipe(eslint.failAfterError());
};


================================================
FILE: gulp/tasks/loadProjectList.js
================================================
var request = require('request');
var PluginError = require('plugin-error');

var projectList = require('../util/projectList');
var config = require('../../app/config.js');
var errorNotifier = require('../util/error');

exports.loadProjectList = function loadProjectList(cb) {
    if (projectList.get()) {
        return cb();
    }

    var fields = [
        'items.bounds',
        'items.zoom_level',
        'items.time_zone',
        'items.code',
        'items.flags',
        'items.country_code',
        'items.domain'
    ].join(',');

    var protocol = config.appConfig.protocol;
    var apiServer = config.appConfig.webApiServer;
    var apiVersion = config.appConfig.webApiVersion;
    var apiKey = config.appConfig.webApiKey;

    var url = protocol + apiServer + '/' + apiVersion + '/region/list?key=' + apiKey + '&fields=' + fields;

    request(url, function(err, res, body) {
        if (err) {
            var error = new PluginError({
                plugin: 'loadProjectList',
                message: err
            });

            errorNotifier.notify(error);

            return cb();
        }

        var data = JSON.parse(body);

        var projects = data.result.items;

        var projectListString = 'DG.fallbackProjectsList = JSON.parse(\'' +
            JSON.stringify(projects) +
            '\');';

        projectList.set(projectListString);

        cb();
    });
};


================================================
FILE: gulp/tasks/loader.js
================================================
var gulp = require('gulp');
var argv = require('minimist')(process.argv.slice(2));
var gulpif = require('gulp-if');
var uglify = require('gulp-uglify');
var replace = require('gulp-replace');

var error = require('../util/error');
var config = require('../../app/config.js');

exports.loader = function loader() {
    var originalBaseUrl = config.appConfig.protocol + config.appConfig.baseUrl;

    return gulp.src('app/loader.js')
        .pipe(error.handle())
        .pipe(replace(/__ORIGINAL_BASE_URL__/g, originalBaseUrl))
        .pipe(gulpif(argv.release, uglify()))
        .pipe(gulp.dest('dist'));
};


================================================
FILE: gulp/tasks/rebuildStyles.js
================================================
var { destCSS } = require('../util/destCSS');

exports.rebuildStyles = destCSS;


================================================
FILE: gulp/tasks/server.js
================================================
var spawn = require('child_process').spawn;

var nodeServer = null;

exports.server = function server(cb) {
    function start() {
        nodeServer = spawn('node', ['app'], {stdio: 'inherit'});
        cb();
    }

    if (nodeServer) {
        nodeServer.once('close', start);
        nodeServer.kill();
    } else {
        start();
    }
};

process.on('exit', function() {
    if (nodeServer) {
        nodeServer.kill();
    }
});


================================================
FILE: gulp/tasks/test.js
================================================
var Server = require('karma').Server;
var argv = require('minimist')(process.argv.slice(2));
var gulp = require('gulp');
var path = require('path');
var glob = require('glob');
var log = require('fancy-log');
var _ = require('lodash');

var { buildTest } = require('./buildTest');

var test = require('../../test/test');
var excludedTests = require('../../test/excludedTests.js') || [];

var isTestDebug = argv.d || argv.debug;
var testRequirements = isTestDebug ? [] : [buildTest];
var itemsInChunk = 10; // items in chunk by default

function performTest(done) {
    var cliOptions = _.cloneDeep(argv);
    var modulesToTest = [];
    var currentChunk = 0;

    var sourcesList = [
        'dist/js/script.full.js',
        'node_modules/leaflet/spec/after.js',
        'node_modules/happen/happen.js',
        'node_modules/prosthetic-hand/dist/prosthetic-hand.js',
        'node_modules/leaflet/spec/suites/SpecHelper.js',
        'node_modules/mock-geolocation/dist/geolocate.js',
        'test/after.js'
    ];

    if ('m' in cliOptions) {
        modulesToTest = cliOptions.m.split(',');
    }

    if ('module' in cliOptions) {
        modulesToTest = cliOptions.module.split(',');
    }

    var modulesToTestSourceList = [];

    if (modulesToTest.length) {
        modulesToTest.forEach(function(moduleName) {
            modulesToTestSourceList = modulesToTestSourceList.concat(glob.sync('src/' + moduleName + '/test/*Spec.js'));
        });
    } else {
        modulesToTestSourceList = modulesToTestSourceList.concat(glob.sync('src/**/test/*Spec.js'));
    }
    modulesToTestSourceList = modulesToTestSourceList.concat(glob.sync('node_modules/leaflet/spec/suites/**/*Spec.js'));

    modulesToTestSourceList = _.difference(modulesToTestSourceList, excludedTests);

    var splittedModules = _.chunk(modulesToTestSourceList, itemsInChunk);

    var numberOfChunks = splittedModules.length;

    log('\nITEMS IN CHUNK: ' + itemsInChunk);
    log('NUMBER OF CHUNKS: ' + numberOfChunks);

    // Flag of existing errors.
    var totalErr = false;

    // Function will be run recursive, because need execute chunks in order.
    function startServer(err) {
        totalErr = err || totalErr;
        log('\nCHUNK #' + currentChunk.toString());

        var localeSourceList = sourcesList.concat(splittedModules[currentChunk]);
        currentChunk++;

        localeSourceList.push('node_modules/leaflet/spec/suites/SpecHelper.js');

        function localDone(errDone) {
            totalErr = errDone || totalErr;
            done(totalErr);
        }

        new Server({
            files: localeSourceList,
            configFile: path.join(__dirname, '../../test/karma.conf.js'),
            browsers: test.getBrowsers(),
            reporters: test.getReporters(isTestDebug),
            junitReporter: test.getJunitReporter(),
            action: 'run',
            preprocessors: {
                'gulp/tmp/testJS/src/**/*.js': ['coverage']
            },
            singleRun: true
            // Function localDone will be executed in the last iteration.
        }, currentChunk === numberOfChunks ? localDone : startServer).start();
    }
    startServer();
}

exports.test = gulp.series(...testRequirements, performTest);


================================================
FILE: gulp/tasks/watch.js
================================================
var gulp = require('gulp');

var { doc } = require('./doc');
var { copyAssets } = require('./copyAssets');
var { server } = require('./server');
var { buildScripts } = require('./buildScripts');
var { rebuildStyles } = require('./rebuildStyles');
var { build } = require('./build');
var { loader } = require('./loader');
var { copyIndexPage } = require('./copyIndexPage');

exports.watch = function watch() {
    gulp.watch('src/doc/**/*.*', doc);

    gulp.watch('assets/**/*', gulp.series(copyAssets, server));

    gulp.watch([
        'src/**/*.js',
        'vendors/leaflet/src/**/*.*'
    ], gulp.series(buildScripts, server));

    gulp.watch('src/**/*.less', gulp.series(rebuildStyles, server));

    gulp.watch('config.main.json', gulp.series(build, server));

    gulp.watch(['app/index.js', 'config.local.json'], server);

    gulp.watch('app/loader.js', gulp.series(loader, server));

    gulp.watch('app/index.html', gulp.series(copyIndexPage, server));
};


================================================
FILE: gulp/util/buildCSS.js
================================================
var autoprefixer = require('gulp-autoprefixer');
var clean = require('gulp-clean-css');
var remember = require('gulp-remember');
var concat = require('gulp-concat');
var header = require('gulp-header');
var cache = require('gulp-cached');
var gulpif = require('gulp-if');
var less = require('gulp-less');
var argv = require('minimist')(process.argv.slice(2));
var map = require('map-stream');
var gulp = require('gulp');
var path = require('path');
var fs = require('fs');

var config = require('../../app/config.js');
var deps = require('../deps')(config);
var stat = require('../util/stat');
var error = require('./error');

exports.buildCSS = function(options) {
    var imagesBasePath = path.resolve(__dirname + '/../../dist/img');
    var baseURL = config.appConfig.protocol + config.appConfig.baseUrl;
    var lessList = deps.getCSSFiles(options);

    var lessHeaderImports;
    if (options.isTest) {
        lessHeaderImports = [
            './src/less/mixins.less:reference',
            './src/less/mixins.ie8.less:reference'
        ];
    } else {
        lessHeaderImports = [
            './gulp/tmp/less/sprite.basic.less:reference',
            './gulp/tmp/less/sprite@2x.basic.less:reference',
            './gulp/tmp/less/sprite.' + options.skin + '.less:reference',
            './gulp/tmp/less/sprite@2x.' + options.skin + '.less:reference',

            './gulp/tmp/less/images-files-statistics.basic.less:reference',
            './gulp/tmp/less/images-files-statistics.' + options.skin + '.less:reference',

            './src/less/mixins.less:reference',
            './src/less/mixins.ie8.less:reference'
        ];
    }

    lessHeaderImports = lessHeaderImports.filter(function(src) {
        var lessFileSrc = src.split(':')[0];

        try {
            return fs.readFileSync(path.join(__dirname, '../..', lessFileSrc));
        } catch (e) {
            return false;
        }
    });

    var lessPrerequirements = deps.lessHeader({
        variables: {
            baseURL: "'" + baseURL + "'",
            skinName: options.skin,
            ie8: options.ie8,
            imagesBasePath: "'" + imagesBasePath + "'"
        },

        imports: lessHeaderImports
    });

    return gulp.src(lessList)
        .pipe(error.handle())
        .pipe(cache('css.' + options.suffix))
        .pipe(header(lessPrerequirements))
        .pipe(less())
        .pipe(autoprefixer({browsers: ['last 2 version', 'safari 5', 'ie 8', 'ie 9', 'opera 12.1', 'ios 6', 'android 4']}))
        .pipe(remember('css.' + options.suffix))
        .pipe(concat('styles.' + (options.suffix ? options.suffix + '.' : '') + 'css'))
        .pipe(gulpif(argv.release, clean()))
        .pipe(header(config.copyright))
        .pipe(map(stat.save));
};


================================================
FILE: gulp/util/buildEnd.js
================================================
var argv = require('minimist')(process.argv.slice(2));
var log = require('fancy-log');

var stat = require('./stat');
var config = require('../../app/config');
var deps = require('../deps')(config);

exports.buildEnd = function buildEnd(done) {
    log('Build contains the next modules:');

    deps.getModulesList(argv.pkg).forEach(function(module) {
        log('- ' + module);
    });

    if (argv.sprite == 'true') {
        log('Builded with sprites');
    } else if (argv.base64 != 'false' && typeof argv.base64 != 'undefined') {
        log('Builded with base64 encode');
    }

    log('\nDist files statistic:');

    var statValues = stat.get();

    Object.keys(statValues).forEach(function(file) {
        log('- ' + file + ': ' + statValues[file]);
    });

    log('Build successfully complete');
    done();
};


================================================
FILE: gulp/util/csslint/gulp-csslint.js
================================================
var log = require('fancy-log');
var PluginError = require('plugin-error');
var es = require('event-stream');
var fs = require('fs');
var csslint = require('./lib/csslint').CSSLint;

var formatOutput = function (report, file, options) {
    if (!report.messages.length) {
        return {
            success: true
        };
    }

    var filePath = file.path || 'stdin';

    // Handle errors
    var results = report.messages.map(function (err) {
        if (!err) {
            return;
        }

        return {
            file: filePath,
            error: err
        };
    }).filter(function (err) {
        return err;
    });

    var output = {
        errorCount: results.length,
        success: false,
        results: results,
        options: options
    };

    return output;
};

var cssLintPlugin = function (options) {
    if (!options) {
        options = {};
    }

    var ruleset = {};

    // Read CSSLint options from a specified csslintrc file.
    if (typeof options == 'string') {
        // Don't catch readFile errors, let them bubble up
        var externalOptions = fs.readFileSync('./' + options);

        try {
            options = JSON.parse(externalOptions);
        } catch(err) {
            throw new Error('Error parsing csslintrc: ' + err);
        }
    }

    // Build a list of all available rules
    csslint.getRules().forEach(function (rule) {
        ruleset[rule.id] = 1;
    });

    for (var rule in options) {
        if (!options[rule]) {
            // Remove rules that are turned off
            delete ruleset[rule];
        } else {
            ruleset[rule] = options[rule];
        }
    }

    return es.map(function (file, cb) {
        var report = csslint.verify(String(file.contents), ruleset);

        // send status down-stream
        file.csslint = formatOutput(report, file, options);

        cb(null, file);
    });
};

var defaultReporter = function (file) {
    var errorCount = file.csslint.errorCount;
    var plural = errorCount == 1 ? '' : 's';

    log(errorCount + ' error' + plural + ' found in ' + file.path);

    file.csslint.results.forEach(function (result) {
        var message = result.error;

        log('[' + (typeof message.line != 'undefined'
                ? 'L' + message.line + ':' + 'C' + message.col
                : 'GENERAL'
            ) + '] ' + message.message + ' ' + message.rule.desc + ' (' + message.rule.id + ')'
        );
    });
};

cssLintPlugin.reporter = function (customReporter) {
    var reporter = defaultReporter;

    if (typeof customReporter == 'function') {
        reporter = customReporter;
    }

    if (typeof reporter == 'undefined') {
        throw new Error('Invalid reporter');
    }

    return es.map(function (file, cb) {
        // Only report if CSSLint was ran and errors were found
        if (file.csslint && !file.csslint.success) {
            reporter(file);
        }

        return cb(null, file);
    });
};

cssLintPlugin.failReporter = function () {
    return es.map(function (file, cb) {
        // Nothing to report or no errors
        if (!file.csslint || file.csslint.success) {
            return cb(null, file);
        }

        return cb(new PluginError('gulp-csslint', 'CSSLint failed for ' + file.relative), file);
    });
};

module.exports = cssLintPlugin;


================================================
FILE: gulp/util/csslint/lib/csslint.js
================================================
/*!
CSSLint
Copyright (c) 2013 Nicole Sullivan and Nicholas C. Zakas. All rights reserved.

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.

*/
/* Build: v0.10.0 15-August-2013 01:07:22 */
var parserlib = require("./parserlib");
/**
 * Main CSSLint object.
 * @class CSSLint
 * @static
 * @extends parserlib.util.EventTarget
 */
/*global parserlib, Reporter*/
var CSSLint = (function(){

    var rules           = [],
        formatters      = [],
        embeddedRuleset = /\/\*csslint([^\*]*)\*\//,
        api             = new parserlib.util.EventTarget();

    api.version = "0.10.0";

    //-------------------------------------------------------------------------
    // Rule Management
    //-------------------------------------------------------------------------

    /**
     * Adds a new rule to the engine.
     * @param {Object} rule The rule to add.
     * @method addRule
     */
    api.addRule = function(rule){
        rules.push(rule);
        rules[rule.id] = rule;
    };

    /**
     * Clears all rule from the engine.
     * @method clearRules
     */
    api.clearRules = function(){
        rules = [];
    };

    /**
     * Returns the rule objects.
     * @return An array of rule objects.
     * @method getRules
     */
    api.getRules = function(){
        return [].concat(rules).sort(function(a,b){
            return a.id > b.id ? 1 : 0;
        });
    };

    /**
     * Returns a ruleset configuration object with all current rules.
     * @return A ruleset object.
     * @method getRuleset
     */
    api.getRuleset = function() {
        var ruleset = {},
            i = 0,
            len = rules.length;

        while (i < len){
            ruleset[rules[i++].id] = 1;    //by default, everything is a warning
        }

        return ruleset;
    };

    /**
     * Returns a ruleset object based on embedded rules.
     * @param {String} text A string of css containing embedded rules.
     * @param {Object} ruleset A ruleset object to modify.
     * @return {Object} A ruleset object.
     * @method getEmbeddedRuleset
     */
    function applyEmbeddedRuleset(text, ruleset){
        var valueMap,
            embedded = text && text.match(embeddedRuleset),
            rules = embedded && embedded[1];

        if (rules) {
            valueMap = {
                "true": 2,  // true is error
                "": 1,      // blank is warning
                "false": 0, // false is ignore

                "2": 2,     // explicit error
                "1": 1,     // explicit warning
                "0": 0      // explicit ignore
            };

            rules.toLowerCase().split(",").forEach(function(rule){
                var pair = rule.split(":"),
                    property = pair[0] || "",
                    value = pair[1] || "";

                ruleset[property.trim()] = valueMap[value.trim()];
            });
        }

        return ruleset;
    }

    //-------------------------------------------------------------------------
    // Formatters
    //-------------------------------------------------------------------------

    /**
     * Adds a new formatter to the engine.
     * @param {Object} formatter The formatter to add.
     * @method addFormatter
     */
    api.addFormatter = function(formatter) {
        // formatters.push(formatter);
        formatters[formatter.id] = formatter;
    };

    /**
     * Retrieves a formatter for use.
     * @param {String} formatId The name of the format to retrieve.
     * @return {Object} The formatter or undefined.
     * @method getFormatter
     */
    api.getFormatter = function(formatId){
        return formatters[formatId];
    };

    /**
     * Formats the results in a particular format for a single file.
     * @param {Object} result The results returned from CSSLint.verify().
     * @param {String} filename The filename for which the results apply.
     * @param {String} formatId The name of the formatter to use.
     * @param {Object} options (Optional) for special output handling.
     * @return {String} A formatted string for the results.
     * @method format
     */
    api.format = function(results, filename, formatId, options) {
        var formatter = this.getFormatter(formatId),
            result = null;

        if (formatter){
            result = formatter.startFormat();
            result += formatter.formatResults(results, filename, options || {});
            result += formatter.endFormat();
        }

        return result;
    };

    /**
     * Indicates if the given format is supported.
     * @param {String} formatId The ID of the format to check.
     * @return {Boolean} True if the format exists, false if not.
     * @method hasFormat
     */
    api.hasFormat = function(formatId){
        return formatters.hasOwnProperty(formatId);
    };

    //-------------------------------------------------------------------------
    // Verification
    //-------------------------------------------------------------------------

    /**
     * Starts the verification process for the given CSS text.
     * @param {String} text The CSS text to verify.
     * @param {Object} ruleset (Optional) List of rules to apply. If null, then
     *      all rules are used. If a rule has a value of 1 then it's a warning,
     *      a value of 2 means it's an error.
     * @return {Object} Results of the verification.
     * @method verify
     */
    api.verify = function(text, ruleset){

        var i       = 0,
            len     = rules.length,
            reporter,
            lines,
            report,
            parser = new parserlib.css.Parser({ starHack: true, ieFilters: true,
                                                underscoreHack: true, strict: false });

        // normalize line endings
        lines = text.replace(/\n\r?/g, "$split$").split('$split$');

        if (!ruleset){
            ruleset = this.getRuleset();
        }

        if (embeddedRuleset.test(text)){
            ruleset = applyEmbeddedRuleset(text, ruleset);
        }

        reporter = new Reporter(lines, ruleset);

        ruleset.errors = 2;       //always report parsing errors as errors
        for (i in ruleset){
            if(ruleset.hasOwnProperty(i) && ruleset[i]){
                if (rules[i]){
                    rules[i].init(parser, reporter);
                }
            }
        }


        //capture most horrible error type
        try {
            parser.parse(text);
        } catch (ex) {
            reporter.error("Fatal error, cannot continue: " + ex.message, ex.line, ex.col, {});
        }

        report = {
            messages    : reporter.messages,
            stats       : reporter.stats,
            ruleset     : reporter.ruleset
        };

        //sort by line numbers, rollups at the bottom
        report.messages.sort(function (a, b){
            if (a.rollup && !b.rollup){
                return 1;
            } else if (!a.rollup && b.rollup){
                return -1;
            } else {
                return a.line - b.line;
            }
        });

        return report;
    };

    //-------------------------------------------------------------------------
    // Publish the API
    //-------------------------------------------------------------------------

    return api;

})();

/*global CSSLint*/
/**
 * An instance of Report is used to report results of the
 * verification back to the main API.
 * @class Reporter
 * @constructor
 * @param {String[]} lines The text lines of the source.
 * @param {Object} ruleset The set of rules to work with, including if
 *      they are errors or warnings.
 */
function Reporter(lines, ruleset){

    /**
     * List of messages being reported.
     * @property messages
     * @type String[]
     */
    this.messages = [];

    /**
     * List of statistics being reported.
     * @property stats
     * @type String[]
     */
    this.stats = [];

    /**
     * Lines of code being reported on. Used to provide contextual information
     * for messages.
     * @property lines
     * @type String[]
     */
    this.lines = lines;

    /**
     * Information about the rules. Used to determine whether an issue is an
     * error or warning.
     * @property ruleset
     * @type Object
     */
    this.ruleset = ruleset;
}

Reporter.prototype = {

    //restore constructor
    constructor: Reporter,

    /**
     * Report an error.
     * @param {String} message The message to store.
     * @param {int} line The line number.
     * @param {int} col The column number.
     * @param {Object} rule The rule this message relates to.
     * @method error
     */
    error: function(message, line, col, rule){
        this.messages.push({
            type    : "error",
            line    : line,
            col     : col,
            message : message,
            evidence: this.lines[line-1],
            rule    : rule || {}
        });
    },

    /**
     * Report an warning.
     * @param {String} message The message to store.
     * @param {int} line The line number.
     * @param {int} col The column number.
     * @param {Object} rule The rule this message relates to.
     * @method warn
     * @deprecated Use report instead.
     */
    warn: function(message, line, col, rule){
        this.report(message, line, col, rule);
    },

    /**
     * Report an issue.
     * @param {String} message The message to store.
     * @param {int} line The line number.
     * @param {int} col The column number.
     * @param {Object} rule The rule this message relates to.
     * @method report
     */
    report: function(message, line, col, rule){
        this.messages.push({
            type    : this.ruleset[rule.id] == 2 ? "error" : "warning",
            line    : line,
            col     : col,
            message : message,
            evidence: this.lines[line-1],
            rule    : rule
        });
    },

    /**
     * Report some informational text.
     * @param {String} message The message to store.
     * @param {int} line The line number.
     * @param {int} col The column number.
     * @param {Object} rule The rule this message relates to.
     * @method info
     */
    info: function(message, line, col, rule){
        this.messages.push({
            type    : "info",
            line    : line,
            col     : col,
            message : message,
            evidence: this.lines[line-1],
            rule    : rule
        });
    },

    /**
     * Report some rollup error information.
     * @param {String} message The message to store.
     * @param {Object} rule The rule this message relates to.
     * @method rollupError
     */
    rollupError: function(message, rule){
        this.messages.push({
            type    : "error",
            rollup  : true,
            message : message,
            rule    : rule
        });
    },

    /**
     * Report some rollup warning information.
     * @param {String} message The message to store.
     * @param {Object} rule The rule this message relates to.
     * @method rollupWarn
     */
    rollupWarn: function(message, rule){
        this.messages.push({
            type    : "warning",
            rollup  : true,
            message : message,
            rule    : rule
        });
    },

    /**
     * Report a statistic.
     * @param {String} name The name of the stat to store.
     * @param {Variant} value The value of the stat.
     * @method stat
     */
    stat: function(name, value){
        this.stats[name] = value;
    }
};

//expose for testing purposes
CSSLint._Reporter = Reporter;

/*global CSSLint*/

/*
 * Utility functions that make life easier.
 */
CSSLint.Util = {
    /*
     * Adds all properties from supplier onto receiver,
     * overwriting if the same name already exists on
     * reciever.
     * @param {Object} The object to receive the properties.
     * @param {Object} The object to provide the properties.
     * @return {Object} The receiver
     */
    mix: function(receiver, supplier){
        var prop;

        for (prop in supplier){
            if (supplier.hasOwnProperty(prop)){
                receiver[prop] = supplier[prop];
            }
        }

        return prop;
    },

    /*
     * Polyfill for array indexOf() method.
     * @param {Array} values The array to search.
     * @param {Variant} value The value to search for.
     * @return {int} The index of the value if found, -1 if not.
     */
    indexOf: function(values, value){
        if (values.indexOf){
            return values.indexOf(value);
        } else {
            for (var i=0, len=values.length; i < len; i++){
                if (values[i] === value){
                    return i;
                }
            }
            return -1;
        }
    },

    /*
     * Polyfill for array forEach() method.
     * @param {Array} values The array to operate on.
     * @param {Function} func The function to call on each item.
     * @return {void}
     */
    forEach: function(values, func) {
        if (values.forEach){
            return values.forEach(func);
        } else {
            for (var i=0, len=values.length; i < len; i++){
                func(values[i], i, values);
            }
        }
    }
};
/*global CSSLint*/
/*
 * Rule: Don't use adjoining classes (.foo.bar).
 */
CSSLint.addRule({

    //rule information
    id: "adjoining-classes",
    name: "Disallow adjoining classes",
    desc: "Don't use adjoining classes.",
    browsers: "IE6",

    //initialization
    init: function(parser, reporter){
        var rule = this;
        parser.addListener("startrule", function(event){
            var selectors = event.selectors,
                selector,
                part,
                modifier,
                classCount,
                i, j, k;

            for (i=0; i < selectors.length; i++){
                selector = selectors[i];
                for (j=0; j < selector.parts.length; j++){
                    part = selector.parts[j];
                    if (part.type == parser.SELECTOR_PART_TYPE){
                        classCount = 0;
                        for (k=0; k < part.modifiers.length; k++){
                            modifier = part.modifiers[k];
                            if (modifier.type == "class"){
                                classCount++;
                            }
                            if (classCount > 1){
                                reporter.report("Don't use adjoining classes.", part.line, part.col, rule);
                            }
                        }
                    }
                }
            }
        });
    }

});
/*global CSSLint*/

/*
 * Rule: Don't use width or height when using padding or border.
 */
CSSLint.addRule({

    //rule information
    id: "box-model",
    name: "Beware of broken box size",
    desc: "Don't use width or height when using padding or border.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            widthProperties = {
                border: 1,
                "border-left": 1,
                "border-right": 1,
                padding: 1,
                "padding-left": 1,
                "padding-right": 1
            },
            heightProperties = {
                border: 1,
                "border-bottom": 1,
                "border-top": 1,
                padding: 1,
                "padding-bottom": 1,
                "padding-top": 1
            },
            properties,
            boxSizing = false;

        function startRule(){
            properties = {};
            boxSizing = false;
        }

        function endRule(){
            var prop, value;

            if (!boxSizing) {
                if (properties.height){
                    for (prop in heightProperties){
                        if (heightProperties.hasOwnProperty(prop) && properties[prop]){
                            value = properties[prop].value;
                            //special case for padding
                            if (!(prop == "padding" && value.parts.length === 2 && value.parts[0].value === 0)){
                                reporter.report("Using height with " + prop + " can sometimes make elements larger than you expect.", properties[prop].line, properties[prop].col, rule);
                            }
                        }
                    }
                }

                if (properties.width){
                    for (prop in widthProperties){
                        if (widthProperties.hasOwnProperty(prop) && properties[prop]){
                            value = properties[prop].value;

                            if (!(prop == "padding" && value.parts.length === 2 && value.parts[1].value === 0)){
                                reporter.report("Using width with " + prop + " can sometimes make elements larger than you expect.", properties[prop].line, properties[prop].col, rule);
                            }
                        }
                    }
                }
            }
        }

        parser.addListener("startrule", startRule);
        parser.addListener("startfontface", startRule);
        parser.addListener("startpage", startRule);
        parser.addListener("startpagemargin", startRule);
        parser.addListener("startkeyframerule", startRule);

        parser.addListener("property", function(event){
            var name = event.property.text.toLowerCase();

            if (heightProperties[name] || widthProperties[name]){
                if (!/^0\S*$/.test(event.value) && !(name == "border" && event.value == "none")){
                    properties[name] = { line: event.property.line, col: event.property.col, value: event.value };
                }
            } else {
                if (/^(width|height)/i.test(name) && /^(length|percentage)/.test(event.value.parts[0].type)){
                    properties[name] = 1;
                } else if (name == "box-sizing") {
                    boxSizing = true;
                }
            }

        });

        parser.addListener("endrule", endRule);
        parser.addListener("endfontface", endRule);
        parser.addListener("endpage", endRule);
        parser.addListener("endpagemargin", endRule);
        parser.addListener("endkeyframerule", endRule);
    }

});
/*global CSSLint*/

/*
 * Rule: box-sizing doesn't work in IE6 and IE7.
 */
CSSLint.addRule({

    //rule information
    id: "box-sizing",
    name: "Disallow use of box-sizing",
    desc: "The box-sizing properties isn't supported in IE6 and IE7.",
    browsers: "IE6, IE7",
    tags: ["Compatibility"],

    //initialization
    init: function(parser, reporter){
        var rule = this;

        parser.addListener("property", function(event){
            var name = event.property.text.toLowerCase();

            if (name == "box-sizing"){
                reporter.report("The box-sizing property isn't supported in IE6 and IE7.", event.line, event.col, rule);
            }
        });
    }

});
/*
 * Rule: Use the bulletproof @font-face syntax to avoid 404's in old IE
 * (http://www.fontspring.com/blog/the-new-bulletproof-font-face-syntax)
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "bulletproof-font-face",
    name: "Use the bulletproof @font-face syntax",
    desc: "Use the bulletproof @font-face syntax to avoid 404's in old IE (http://www.fontspring.com/blog/the-new-bulletproof-font-face-syntax).",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            count = 0,
            fontFaceRule = false,
            firstSrc     = true,
            ruleFailed    = false,
            line, col;

        // Mark the start of a @font-face declaration so we only test properties inside it
        parser.addListener("startfontface", function(event){
            fontFaceRule = true;
        });

        parser.addListener("property", function(event){
            // If we aren't inside an @font-face declaration then just return
            if (!fontFaceRule) {
                return;
            }

            var propertyName = event.property.toString().toLowerCase(),
                value        = event.value.toString();

            // Set the line and col numbers for use in the endfontface listener
            line = event.line;
            col  = event.col;

            // This is the property that we care about, we can ignore the rest
            if (propertyName === 'src') {
                var regex = /^\s?url\(['"].+\.eot\?.*['"]\)\s*format\(['"]embedded-opentype['"]\).*$/i;

                // We need to handle the advanced syntax with two src properties
                if (!value.match(regex) && firstSrc) {
                    ruleFailed = true;
                    firstSrc = false;
                } else if (value.match(regex) && !firstSrc) {
                    ruleFailed = false;
                }
            }


        });

        // Back to normal rules that we don't need to test
        parser.addListener("endfontface", function(event){
            fontFaceRule = false;

            if (ruleFailed) {
                reporter.report("@font-face declaration doesn't follow the fontspring bulletproof syntax.", line, col, rule);
            }
        });
    }
});
/*
 * Rule: Include all compatible vendor prefixes to reach a wider
 * range of users.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "compatible-vendor-prefixes",
    name: "Require compatible vendor prefixes",
    desc: "Include all compatible vendor prefixes to reach a wider range of users.",
    browsers: "All",

    //initialization
    init: function (parser, reporter) {
        var rule = this,
            compatiblePrefixes,
            properties,
            prop,
            variations,
            prefixed,
            i,
            len,
            inKeyFrame = false,
            arrayPush = Array.prototype.push,
            applyTo = [];

        // See http://peter.sh/experiments/vendor-prefixed-css-property-overview/ for details
        compatiblePrefixes = {
            "animation"                  : "webkit moz",
            "animation-delay"            : "webkit moz",
            "animation-direction"        : "webkit moz",
            "animation-duration"         : "webkit moz",
            "animation-fill-mode"        : "webkit moz",
            "animation-iteration-count"  : "webkit moz",
            "animation-name"             : "webkit moz",
            "animation-play-state"       : "webkit moz",
            "animation-timing-function"  : "webkit moz",
            "appearance"                 : "webkit moz",
            "border-end"                 : "webkit moz",
            "border-end-color"           : "webkit moz",
            "border-end-style"           : "webkit moz",
            "border-end-width"           : "webkit moz",
            "border-image"               : "webkit moz o",
            "border-radius"              : "webkit",
            "border-start"               : "webkit moz",
            "border-start-color"         : "webkit moz",
            "border-start-style"         : "webkit moz",
            "border-start-width"         : "webkit moz",
            "box-align"                  : "webkit moz ms",
            "box-direction"              : "webkit moz ms",
            "box-flex"                   : "webkit moz ms",
            "box-lines"                  : "webkit ms",
            "box-ordinal-group"          : "webkit moz ms",
            "box-orient"                 : "webkit moz ms",
            "box-pack"                   : "webkit moz ms",
            "box-sizing"                 : "webkit moz",
            "box-shadow"                 : "webkit moz",
            "column-count"               : "webkit moz ms",
            "column-gap"                 : "webkit moz ms",
            "column-rule"                : "webkit moz ms",
            "column-rule-color"          : "webkit moz ms",
            "column-rule-style"          : "webkit moz ms",
            "column-rule-width"          : "webkit moz ms",
            "column-width"               : "webkit moz ms",
            "hyphens"                    : "epub moz",
            "line-break"                 : "webkit ms",
            "margin-end"                 : "webkit moz",
            "margin-start"               : "webkit moz",
            "marquee-speed"              : "webkit wap",
            "marquee-style"              : "webkit wap",
            "padding-end"                : "webkit moz",
            "padding-start"              : "webkit moz",
            "tab-size"                   : "moz o",
            "text-size-adjust"           : "webkit ms",
            "transform"                  : "webkit moz ms o",
            "transform-origin"           : "webkit moz ms o",
            "transition"                 : "webkit moz o",
            "transition-delay"           : "webkit moz o",
            "transition-duration"        : "webkit moz o",
            "transition-property"        : "webkit moz o",
            "transition-timing-function" : "webkit moz o",
            "user-modify"                : "webkit moz",
            "user-select"                : "webkit moz ms",
            "word-break"                 : "epub ms",
            "writing-mode"               : "epub ms"
        };


        for (prop in compatiblePrefixes) {
            if (compatiblePrefixes.hasOwnProperty(prop)) {
                variations = [];
                prefixed = compatiblePrefixes[prop].split(' ');
                for (i = 0, len = prefixed.length; i < len; i++) {
                    variations.push('-' + prefixed[i] + '-' + prop);
                }
                compatiblePrefixes[prop] = variations;
                arrayPush.apply(applyTo, variations);
            }
        }

        parser.addListener("startrule", function () {
            properties = [];
        });

        parser.addListener("startkeyframes", function (event) {
            inKeyFrame = event.prefix || true;
        });

        parser.addListener("endkeyframes", function (event) {
            inKeyFrame = false;
        });

        parser.addListener("property", function (event) {
            var name = event.property;
            if (CSSLint.Util.indexOf(applyTo, name.text) > -1) {

                // e.g., -moz-transform is okay to be alone in @-moz-keyframes
                if (!inKeyFrame || typeof inKeyFrame != "string" ||
                        name.text.indexOf("-" + inKeyFrame + "-") !== 0) {
                    properties.push(name);
                }
            }
        });

        parser.addListener("endrule", function (event) {
            if (!properties.length) {
                return;
            }

            var propertyGroups = {},
                i,
                len,
                name,
                prop,
                variations,
                value,
                full,
                actual,
                item,
                propertiesSpecified;

            for (i = 0, len = properties.length; i < len; i++) {
                name = properties[i];

                for (prop in compatiblePrefixes) {
                    if (compatiblePrefixes.hasOwnProperty(prop)) {
                        variations = compatiblePrefixes[prop];
                        if (CSSLint.Util.indexOf(variations, name.text) > -1) {
                            if (!propertyGroups[prop]) {
                                propertyGroups[prop] = {
                                    full : variations.slice(0),
                                    actual : [],
                                    actualNodes: []
                                };
                            }
                            if (CSSLint.Util.indexOf(propertyGroups[prop].actual, name.text) === -1) {
                                propertyGroups[prop].actual.push(name.text);
                                propertyGroups[prop].actualNodes.push(name);
                            }
                        }
                    }
                }
            }

            for (prop in propertyGroups) {
                if (propertyGroups.hasOwnProperty(prop)) {
                    value = propertyGroups[prop];
                    full = value.full;
                    actual = value.actual;

                    if (full.length > actual.length) {
                        for (i = 0, len = full.length; i < len; i++) {
                            item = full[i];
                            if (CSSLint.Util.indexOf(actual, item) === -1) {
                                propertiesSpecified = (actual.length === 1) ? actual[0] : (actual.length == 2) ? actual.join(" and ") : actual.join(", ");
                                reporter.report("The property " + item + " is compatible with " + propertiesSpecified + " and should be included as well.", value.actualNodes[0].line, value.actualNodes[0].col, rule);
                            }
                        }

                    }
                }
            }
        });
    }
});
/*
 * Rule: Certain properties don't play well with certain display values.
 * - float should not be used with inline-block
 * - height, width, margin-top, margin-bottom, float should not be used with inline
 * - vertical-align should not be used with block
 * - margin, float should not be used with table-*
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "display-property-grouping",
    name: "Require properties appropriate for display",
    desc: "Certain properties shouldn't be used with certain display property values.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        var propertiesToCheck = {
                display: 1,
                "float": "none",
                height: 1,
                width: 1,
                margin: 1,
                "margin-left": 1,
                "margin-right": 1,
                "margin-bottom": 1,
                "margin-top": 1,
                padding: 1,
                "padding-left": 1,
                "padding-right": 1,
                "padding-bottom": 1,
                "padding-top": 1,
                "vertical-align": 1
            },
            properties;

        function reportProperty(name, display, msg){
            if (properties[name]){
                if (typeof propertiesToCheck[name] != "string" || properties[name].value.toLowerCase() != propertiesToCheck[name]){
                    reporter.report(msg || name + " can't be used with display: " + display + ".", properties[name].line, properties[name].col, rule);
                }
            }
        }

        function startRule(){
            properties = {};
        }

        function endRule(){

            var display = properties.display ? properties.display.value : null;
            if (display){
                switch(display){

                    case "inline":
                        //height, width, margin-top, margin-bottom, float should not be used with inline
                        reportProperty("height", display);
                        reportProperty("width", display);
                        reportProperty("margin", display);
                        reportProperty("margin-top", display);
                        reportProperty("margin-bottom", display);
                        reportProperty("float", display, "display:inline has no effect on floated elements (but may be used to fix the IE6 double-margin bug).");
                        break;

                    case "block":
                        //vertical-align should not be used with block
                        reportProperty("vertical-align", display);
                        break;

                    case "inline-block":
                        //float should not be used with inline-block
                        reportProperty("float", display);
                        break;

                    default:
                        //margin, float should not be used with table
                        if (display.indexOf("table-") === 0){
                            reportProperty("margin", display);
                            reportProperty("margin-left", display);
                            reportProperty("margin-right", display);
                            reportProperty("margin-top", display);
                            reportProperty("margin-bottom", display);
                            reportProperty("float", display);
                        }

                        //otherwise do nothing
                }
            }

        }

        parser.addListener("startrule", startRule);
        parser.addListener("startfontface", startRule);
        parser.addListener("startkeyframerule", startRule);
        parser.addListener("startpagemargin", startRule);
        parser.addListener("startpage", startRule);

        parser.addListener("property", function(event){
            var name = event.property.text.toLowerCase();

            if (propertiesToCheck[name]){
                properties[name] = { value: event.value.text, line: event.property.line, col: event.property.col };
            }
        });

        parser.addListener("endrule", endRule);
        parser.addListener("endfontface", endRule);
        parser.addListener("endkeyframerule", endRule);
        parser.addListener("endpagemargin", endRule);
        parser.addListener("endpage", endRule);

    }

});
/*
 * Rule: Disallow duplicate background-images (using url).
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "duplicate-background-images",
    name: "Disallow duplicate background images",
    desc: "Every background-image should be unique. Use a common class for e.g. sprites.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            stack = {};

        parser.addListener("property", function(event){
            var name = event.property.text,
                value = event.value,
                i, len;

            if (name.match(/background/i)) {
                for (i=0, len=value.parts.length; i < len; i++) {
                    if (value.parts[i].type == 'uri') {
                        if (typeof stack[value.parts[i].uri] === 'undefined') {
                            stack[value.parts[i].uri] = event;
                        }
                        else {
                            reporter.report("Background image '" + value.parts[i].uri + "' was used multiple times, first declared at line " + stack[value.parts[i].uri].line + ", col " + stack[value.parts[i].uri].col + ".", event.line, event.col, rule);
                        }
                    }
                }
            }
        });
    }
});
/*
 * Rule: Duplicate properties must appear one after the other. If an already-defined
 * property appears somewhere else in the rule, then it's likely an error.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "duplicate-properties",
    name: "Disallow duplicate properties",
    desc: "Duplicate properties must appear one after the other.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            properties,
            lastProperty;

        function startRule(event){
            properties = {};
        }

        parser.addListener("startrule", startRule);
        parser.addListener("startfontface", startRule);
        parser.addListener("startpage", startRule);
        parser.addListener("startpagemargin", startRule);
        parser.addListener("startkeyframerule", startRule);

        parser.addListener("property", function(event){
            var property = event.property,
                name = property.text.toLowerCase();

            if (properties[name] && (lastProperty != name || properties[name] == event.value.text)){
                reporter.report("Duplicate property '" + event.property + "' found.", event.line, event.col, rule);
            }

            properties[name] = event.value.text;
            lastProperty = name;

        });


    }

});
/*
 * Rule: Style rules without any properties defined should be removed.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "empty-rules",
    name: "Disallow empty rules",
    desc: "Rules without any properties specified should be removed.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            count = 0;

        parser.addListener("startrule", function(){
            count=0;
        });

        parser.addListener("property", function(){
            count++;
        });

        parser.addListener("endrule", function(event){
            var selectors = event.selectors;
            if (count === 0){
                reporter.report("Rule is empty.", selectors[0].line, selectors[0].col, rule);
            }
        });
    }

});
/*
 * Rule: There should be no syntax errors. (Duh.)
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "errors",
    name: "Parsing Errors",
    desc: "This rule looks for recoverable syntax errors.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        parser.addListener("error", function(event){
            reporter.error(event.message, event.line, event.col, rule);
        });

    }

});

/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "fallback-colors",
    name: "Require fallback colors",
    desc: "For older browsers that don't support RGBA, HSL, or HSLA, provide a fallback color.",
    browsers: "IE6,IE7,IE8",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            lastProperty,
            propertiesToCheck = {
                color: 1,
                background: 1,
                "border-color": 1,
                "border-top-color": 1,
                "border-right-color": 1,
                "border-bottom-color": 1,
                "border-left-color": 1,
                border: 1,
                "border-top": 1,
                "border-right": 1,
                "border-bottom": 1,
                "border-left": 1,
                "background-color": 1
            },
            properties;

        function startRule(event){
            properties = {};
            lastProperty = null;
        }

        parser.addListener("startrule", startRule);
        parser.addListener("startfontface", startRule);
        parser.addListener("startpage", startRule);
        parser.addListener("startpagemargin", startRule);
        parser.addListener("startkeyframerule", startRule);

        parser.addListener("property", function(event){
            var property = event.property,
                name = property.text.toLowerCase(),
                parts = event.value.parts,
                i = 0,
                colorType = "",
                len = parts.length;

            if(propertiesToCheck[name]){
                while(i < len){
                    if (parts[i].type == "color"){
                        if ("alpha" in parts[i] || "hue" in parts[i]){

                            if (/([^\)]+)\(/.test(parts[i])){
                                colorType = RegExp.$1.toUpperCase();
                            }

                            if (!lastProperty || (lastProperty.property.text.toLowerCase() != name || lastProperty.colorType != "compat")){
                                reporter.report("Fallback " + name + " (hex or RGB) should precede " + colorType + " " + name + ".", event.line, event.col, rule);
                            }
                        } else {
                            event.colorType = "compat";
                        }
                    }

                    i++;
                }
            }

            lastProperty = event;
        });

    }

});
/*
 * Rule: You shouldn't use more than 10 floats. If you do, there's probably
 * room for some abstraction.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "floats",
    name: "Disallow too many floats",
    desc: "This rule tests if the float property is used too many times",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;
        var count = 0;

        //count how many times "float" is used
        parser.addListener("property", function(event){
            if (event.property.text.toLowerCase() == "float" &&
                    event.value.text.toLowerCase() != "none"){
                count++;
            }
        });

        //report the results
        parser.addListener("endstylesheet", function(){
            reporter.stat("floats", count);
            if (count >= 10){
                reporter.rollupWarn("Too many floats (" + count + "), you're probably using them for layout. Consider using a grid system instead.", rule);
            }
        });
    }

});
/*
 * Rule: Avoid too many @font-face declarations in the same stylesheet.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "font-faces",
    name: "Don't use too many web fonts",
    desc: "Too many different web fonts in the same stylesheet.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            count = 0;


        parser.addListener("startfontface", function(){
            count++;
        });

        parser.addListener("endstylesheet", function(){
            if (count > 5){
                reporter.rollupWarn("Too many @font-face declarations (" + count + ").", rule);
            }
        });
    }

});
/*
 * Rule: You shouldn't need more than 9 font-size declarations.
 */

/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "font-sizes",
    name: "Disallow too many font sizes",
    desc: "Checks the number of font-size declarations.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            count = 0;

        //check for use of "font-size"
        parser.addListener("property", function(event){
            if (event.property == "font-size"){
                count++;
            }
        });

        //report the results
        parser.addListener("endstylesheet", function(){
            reporter.stat("font-sizes", count);
            if (count >= 10){
                reporter.rollupWarn("Too many font-size declarations (" + count + "), abstraction needed.", rule);
            }
        });
    }

});
/*
 * Rule: When using a vendor-prefixed gradient, make sure to use them all.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "gradients",
    name: "Require all gradient definitions",
    desc: "When using a vendor-prefixed gradient, make sure to use them all.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            gradients;

        parser.addListener("startrule", function(){
            gradients = {
                moz: 0,
                webkit: 0,
                oldWebkit: 0,
                o: 0
            };
        });

        parser.addListener("property", function(event){

            if (/\-(moz|o|webkit)(?:\-(?:linear|radial))\-gradient/i.test(event.value)){
                gradients[RegExp.$1] = 1;
            } else if (/\-webkit\-gradient/i.test(event.value)){
                gradients.oldWebkit = 1;
            }

        });

        parser.addListener("endrule", function(event){
            var missing = [];

            if (!gradients.moz){
                missing.push("Firefox 3.6+");
            }

            if (!gradients.webkit){
                missing.push("Webkit (Safari 5+, Chrome)");
            }

            if (!gradients.oldWebkit){
                missing.push("Old Webkit (Safari 4+, Chrome)");
            }

            if (!gradients.o){
                missing.push("Opera 11.1+");
            }

            if (missing.length && missing.length < 4){
                reporter.report("Missing vendor-prefixed CSS gradients for " + missing.join(", ") + ".", event.selectors[0].line, event.selectors[0].col, rule);
            }

        });

    }

});

/*
 * Rule: Don't use IDs for selectors.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "ids",
    name: "Disallow IDs in selectors",
    desc: "Selectors should not contain IDs.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;
        parser.addListener("startrule", function(event){
            var selectors = event.selectors,
                selector,
                part,
                modifier,
                idCount,
                i, j, k;

            for (i=0; i < selectors.length; i++){
                selector = selectors[i];
                idCount = 0;

                for (j=0; j < selector.parts.length; j++){
                    part = selector.parts[j];
                    if (part.type == parser.SELECTOR_PART_TYPE){
                        for (k=0; k < part.modifiers.length; k++){
                            modifier = part.modifiers[k];
                            if (modifier.type == "id"){
                                idCount++;
                            }
                        }
                    }
                }

                if (idCount == 1){
                    reporter.report("Don't use IDs in selectors.", selector.line, selector.col, rule);
                } else if (idCount > 1){
                    reporter.report(idCount + " IDs in the selector, really?", selector.line, selector.col, rule);
                }
            }

        });
    }

});
/*
 * Rule: Don't use @import, use <link> instead.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "import",
    name: "Disallow @import",
    desc: "Don't use @import, use <link> instead.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        parser.addListener("import", function(event){
            reporter.report("@import prevents parallel downloads, use <link> instead.", event.line, event.col, rule);
        });

    }

});
/*
 * Rule: Make sure !important is not overused, this could lead to specificity
 * war. Display a warning on !important declarations, an error if it's
 * used more at least 10 times.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "important",
    name: "Disallow !important",
    desc: "Be careful when using !important declaration",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            count = 0;

        //warn that important is used and increment the declaration counter
        parser.addListener("property", function(event){
            if (event.important === true){
                count++;
                reporter.report("Use of !important", event.line, event.col, rule);
            }
        });

        //if there are more than 10, show an error
        parser.addListener("endstylesheet", function(){
            reporter.stat("important", count);
            if (count >= 10){
                reporter.rollupWarn("Too many !important declarations (" + count + "), try to use less than 10 to avoid specificity issues.", rule);
            }
        });
    }

});
/*
 * Rule: Properties should be known (listed in CSS3 specification) or
 * be a vendor-prefixed property.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "known-properties",
    name: "Require use of known properties",
    desc: "Properties should be known (listed in CSS3 specification) or be a vendor-prefixed property.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        parser.addListener("property", function(event){
            var name = event.property.text.toLowerCase();

            // the check is handled entirely by the parser-lib (https://github.com/nzakas/parser-lib)
            if (event.invalid) {
                reporter.report(event.invalid.message, event.line, event.col, rule);
            }

        });
    }

});
/*
 * Rule: outline: none or outline: 0 should only be used in a :focus rule
 *       and only if there are other properties in the same rule.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "outline-none",
    name: "Disallow outline: none",
    desc: "Use of outline: none or outline: 0 should be limited to :focus rules.",
    browsers: "All",
    tags: ["Accessibility"],

    //initialization
    init: function(parser, reporter){
        var rule = this,
            lastRule;

        function startRule(event){
            if (event.selectors){
                lastRule = {
                    line: event.line,
                    col: event.col,
                    selectors: event.selectors,
                    propCount: 0,
                    outline: false
                };
            } else {
                lastRule = null;
            }
        }

        function endRule(event){
            if (lastRule){
                if (lastRule.outline){
                    if (lastRule.selectors.toString().toLowerCase().indexOf(":focus") == -1){
                        reporter.report("Outlines should only be modified using :focus.", lastRule.line, lastRule.col, rule);
                    } else if (lastRule.propCount == 1) {
                        reporter.report("Outlines shouldn't be hidden unless other visual changes are made.", lastRule.line, lastRule.col, rule);
                    }
                }
            }
        }

        parser.addListener("startrule", startRule);
        parser.addListener("startfontface", startRule);
        parser.addListener("startpage", startRule);
        parser.addListener("startpagemargin", startRule);
        parser.addListener("startkeyframerule", startRule);

        parser.addListener("property", function(event){
            var name = event.property.text.toLowerCase(),
                value = event.value;

            if (lastRule){
                lastRule.propCount++;
                if (name == "outline" && (value == "none" || value == "0")){
                    lastRule.outline = true;
                }
            }

        });

        parser.addListener("endrule", endRule);
        parser.addListener("endfontface", endRule);
        parser.addListener("endpage", endRule);
        parser.addListener("endpagemargin", endRule);
        parser.addListener("endkeyframerule", endRule);

    }

});
/*
 * Rule: Don't use classes or IDs with elements (a.foo or a#foo).
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "overqualified-elements",
    name: "Disallow overqualified elements",
    desc: "Don't use classes or IDs with elements (a.foo or a#foo).",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            classes = {};

        parser.addListener("startrule", function(event){
            var selectors = event.selectors,
                selector,
                part,
                modifier,
                i, j, k;

            for (i=0; i < selectors.length; i++){
                selector = selectors[i];

                for (j=0; j < selector.parts.length; j++){
                    part = selector.parts[j];
                    if (part.type == parser.SELECTOR_PART_TYPE){
                        for (k=0; k < part.modifiers.length; k++){
                            modifier = part.modifiers[k];
                            if (part.elementName && modifier.type == "id"){
                                reporter.report("Element (" + part + ") is overqualified, just use " + modifier + " without element name.", part.line, part.col, rule);
                            } else if (modifier.type == "class"){

                                if (!classes[modifier]){
                                    classes[modifier] = [];
                                }
                                classes[modifier].push({ modifier: modifier, part: part });
                            }
                        }
                    }
                }
            }
        });

        parser.addListener("endstylesheet", function(){

            var prop;
            for (prop in classes){
                if (classes.hasOwnProperty(prop)){

                    //one use means that this is overqualified
                    if (classes[prop].length == 1 && classes[prop][0].part.elementName){
                        reporter.report("Element (" + classes[prop][0].part + ") is overqualified, just use " + classes[prop][0].modifier + " without element name.", classes[prop][0].part.line, classes[prop][0].part.col, rule);
                    }
                }
            }
        });
    }

});
/*
 * Rule: Headings (h1-h6) should not be qualified (namespaced).
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "qualified-headings",
    name: "Disallow qualified headings",
    desc: "Headings should not be qualified (namespaced).",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        parser.addListener("startrule", function(event){
            var selectors = event.selectors,
                selector,
                part,
                i, j;

            for (i=0; i < selectors.length; i++){
                selector = selectors[i];

                for (j=0; j < selector.parts.length; j++){
                    part = selector.parts[j];
                    if (part.type == parser.SELECTOR_PART_TYPE){
                        if (part.elementName && /h[1-6]/.test(part.elementName.toString()) && j > 0){
                            reporter.report("Heading (" + part.elementName + ") should not be qualified.", part.line, part.col, rule);
                        }
                    }
                }
            }
        });
    }

});
/*
 * Rule: Selectors that look like regular expressions are slow and should be avoided.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "regex-selectors",
    name: "Disallow selectors that look like regexs",
    desc: "Selectors that look like regular expressions are slow and should be avoided.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        parser.addListener("startrule", function(event){
            var selectors = event.selectors,
                selector,
                part,
                modifier,
                i, j, k;

            for (i=0; i < selectors.length; i++){
                selector = selectors[i];
                for (j=0; j < selector.parts.length; j++){
                    part = selector.parts[j];
                    if (part.type == parser.SELECTOR_PART_TYPE){
                        for (k=0; k < part.modifiers.length; k++){
                            modifier = part.modifiers[k];
                            if (modifier.type == "attribute"){
                                if (/([\~\|\^\$\*]=)/.test(modifier)){
                                    reporter.report("Attribute selectors with " + RegExp.$1 + " are slow!", modifier.line, modifier.col, rule);
                                }
                            }

                        }
                    }
                }
            }
        });
    }

});
/*
 * Rule: Total number of rules should not exceed x.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "rules-count",
    name: "Rules Count",
    desc: "Track how many rules there are.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            count = 0;

        //count each rule
        parser.addListener("startrule", function(){
            count++;
        });

        parser.addListener("endstylesheet", function(){
            reporter.stat("rule-count", count);
        });
    }

});
/*
 * Rule: Warn people with approaching the IE 4095 limit
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "selector-max-approaching",
    name: "Warn when approaching the 4095 selector limit for IE",
    desc: "Will warn when selector count is >= 3800 selectors.",
    browsers: "IE",

    //initialization
    init: function(parser, reporter) {
        var rule = this, count = 0;

        parser.addListener('startrule', function(event) {
            count += event.selectors.length;
        });

        parser.addListener("endstylesheet", function() {
            if (count >= 3800) {
                reporter.report("You have " + count + " selectors. Internet Explorer supports a maximum of 4095 selectors per stylesheet. Consider refactoring.",0,0,rule);
            }
        });
    }

});

/*
 * Rule: Warn people past the IE 4095 limit
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "selector-max",
    name: "Error when past the 4095 selector limit for IE",
    desc: "Will error when selector count is > 4095.",
    browsers: "IE",

    //initialization
    init: function(parser, reporter){
        var rule = this, count = 0;

        parser.addListener('startrule',function(event) {
            count += event.selectors.length;
        });

        parser.addListener("endstylesheet", function() {
            if (count > 4095) {
                reporter.report("You have " + count + " selectors. Internet Explorer supports a maximum of 4095 selectors per stylesheet. Consider refactoring.",0,0,rule);
            }
        });
    }

});
/*
 * Rule: Use shorthand properties where possible.
 *
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "shorthand",
    name: "Require shorthand properties",
    desc: "Use shorthand properties where possible.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            prop, i, len,
            propertiesToCheck = {},
            properties,
            mapping = {
                "margin": [
                    "margin-top",
                    "margin-bottom",
                    "margin-left",
                    "margin-right"
                ],
                "padding": [
                    "padding-top",
                    "padding-bottom",
                    "padding-left",
                    "padding-right"
                ]
            };

        //initialize propertiesToCheck
        for (prop in mapping){
            if (mapping.hasOwnProperty(prop)){
                for (i=0, len=mapping[prop].length; i < len; i++){
                    propertiesToCheck[mapping[prop][i]] = prop;
                }
            }
        }

        function startRule(event){
            properties = {};
        }

        //event handler for end of rules
        function endRule(event){

            var prop, i, len, total;

            //check which properties this rule has
            for (prop in mapping){
                if (mapping.hasOwnProperty(prop)){
                    total=0;

                    for (i=0, len=mapping[prop].length; i < len; i++){
                        total += properties[mapping[prop][i]] ? 1 : 0;
                    }

                    if (total == mapping[prop].length){
                        reporter.report("The properties " + mapping[prop].join(", ") + " can be replaced by " + prop + ".", event.line, event.col, rule);
                    }
                }
            }
        }

        parser.addListener("startrule", startRule);
        parser.addListener("startfontface", startRule);

        //check for use of "font-size"
        parser.addListener("property", function(event){
            var name = event.property.toString().toLowerCase(),
                value = event.value.parts[0].value;

            if (propertiesToCheck[name]){
                properties[name] = 1;
            }
        });

        parser.addListener("endrule", endRule);
        parser.addListener("endfontface", endRule);

    }

});
/*
 * Rule: Don't use properties with a star prefix.
 *
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "star-property-hack",
    name: "Disallow properties with a star prefix",
    desc: "Checks for the star property hack (targets IE6/7)",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        //check if property name starts with "*"
        parser.addListener("property", function(event){
            var property = event.property;

            if (property.hack == "*") {
                reporter.report("Property with star prefix found.", event.property.line, event.property.col, rule);
            }
        });
    }
});
/*
 * Rule: Don't use text-indent for image replacement if you need to support rtl.
 *
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "text-indent",
    name: "Disallow negative text-indent",
    desc: "Checks for text indent less than -99px",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            textIndent,
            direction;


        function startRule(event){
            textIndent = false;
            direction = "inherit";
        }

        //event handler for end of rules
        function endRule(event){
            if (textIndent && direction != "ltr"){
                reporter.report("Negative text-indent doesn't work well with RTL. If you use text-indent for image replacement explicitly set direction for that item to ltr.", textIndent.line, textIndent.col, rule);
            }
        }

        parser.addListener("startrule", startRule);
        parser.addListener("startfontface", startRule);

        //check for use of "font-size"
        parser.addListener("property", function(event){
            var name = event.property.toString().toLowerCase(),
                value = event.value;

            if (name == "text-indent" && value.parts[0].value < -99){
                textIndent = event.property;
            } else if (name == "direction" && value == "ltr"){
                direction = "ltr";
            }
        });

        parser.addListener("endrule", endRule);
        parser.addListener("endfontface", endRule);

    }

});
/*
 * Rule: Don't use properties with a underscore prefix.
 *
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "underscore-property-hack",
    name: "Disallow properties with an underscore prefix",
    desc: "Checks for the underscore property hack (targets IE6)",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        //check if property name starts with "_"
        parser.addListener("property", function(event){
            var property = event.property;

            if (property.hack == "_") {
                reporter.report("Property with underscore prefix found.", event.property.line, event.property.col, rule);
            }
        });
    }
});
/*
 * Rule: Headings (h1-h6) should be defined only once.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "unique-headings",
    name: "Headings should only be defined once",
    desc: "Headings should be defined only once.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        var headings =  {
                h1: 0,
                h2: 0,
                h3: 0,
                h4: 0,
                h5: 0,
                h6: 0
            };

        parser.addListener("startrule", function(event){
            var selectors = event.selectors,
                selector,
                part,
                pseudo,
                i, j;

            for (i=0; i < selectors.length; i++){
                selector = selectors[i];
                part = selector.parts[selector.parts.length-1];

                if (part.elementName && /(h[1-6])/i.test(part.elementName.toString())){

                    for (j=0; j < part.modifiers.length; j++){
                        if (part.modifiers[j].type == "pseudo"){
                            pseudo = true;
                            break;
                        }
                    }

                    if (!pseudo){
                        headings[RegExp.$1]++;
                        if (headings[RegExp.$1] > 1) {
                            reporter.report("Heading (" + part.elementName + ") has already been defined.", part.line, part.col, rule);
                        }
                    }
                }
            }
        });

        parser.addListener("endstylesheet", function(event){
            var prop,
                messages = [];

            for (prop in headings){
                if (headings.hasOwnProperty(prop)){
                    if (headings[prop] > 1){
                        messages.push(headings[prop] + " " + prop + "s");
                    }
                }
            }

            if (messages.length){
                reporter.rollupWarn("You have " + messages.join(", ") + " defined in this stylesheet.", rule);
            }
        });
    }

});
/*
 * Rule: Don't use universal selector because it's slow.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "universal-selector",
    name: "Disallow universal selector",
    desc: "The universal selector (*) is known to be slow.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        parser.addListener("startrule", function(event){
            var selectors = event.selectors,
                selector,
                part,
                modifier,
                i, j, k;

            for (i=0; i < selectors.length; i++){
                selector = selectors[i];

                part = selector.parts[selector.parts.length-1];
                if (part.elementName == "*"){
                    reporter.report(rule.desc, part.line, part.col, rule);
                }
            }
        });
    }

});
/*
 * Rule: Don't use unqualified attribute selectors because they're just like universal selectors.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "unqualified-attributes",
    name: "Disallow unqualified attribute selectors",
    desc: "Unqualified attribute selectors are known to be slow.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        parser.addListener("startrule", function(event){

            var selectors = event.selectors,
                selector,
                part,
                modifier,
                i, j, k;

            for (i=0; i < selectors.length; i++){
                selector = selectors[i];

                part = selector.parts[selector.parts.length-1];
                if (part.type == parser.SELECTOR_PART_TYPE){
                    for (k=0; k < part.modifiers.length; k++){
                        modifier = part.modifiers[k];
                        if (modifier.type == "attribute" && (!part.elementName || part.elementName == "*")){
                            reporter.report(rule.desc, part.line, part.col, rule);
                        }
                    }
                }

            }
        });
    }

});
/*
 * Rule: When using a vendor-prefixed property, make sure to
 * include the standard one.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "vendor-prefix",
    name: "Require standard property with vendor prefix",
    desc: "When using a vendor-prefixed property, make sure to include the standard one.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this,
            properties,
            num,
            propertiesToCheck = {
                "-webkit-border-radius": "border-radius",
                "-webkit-border-top-left-radius": "border-top-left-radius",
                "-webkit-border-top-right-radius": "border-top-right-radius",
                "-webkit-border-bottom-left-radius": "border-bottom-left-radius",
                "-webkit-border-bottom-right-radius": "border-bottom-right-radius",

                "-o-border-radius": "border-radius",
                "-o-border-top-left-radius": "border-top-left-radius",
                "-o-border-top-right-radius": "border-top-right-radius",
                "-o-border-bottom-left-radius": "border-bottom-left-radius",
                "-o-border-bottom-right-radius": "border-bottom-right-radius",

                "-moz-border-radius": "border-radius",
                "-moz-border-radius-topleft": "border-top-left-radius",
                "-moz-border-radius-topright": "border-top-right-radius",
                "-moz-border-radius-bottomleft": "border-bottom-left-radius",
                "-moz-border-radius-bottomright": "border-bottom-right-radius",

                "-moz-column-count": "column-count",
                "-webkit-column-count": "column-count",

                "-moz-column-gap": "column-gap",
                "-webkit-column-gap": "column-gap",

                "-moz-column-rule": "column-rule",
                "-webkit-column-rule": "column-rule",

                "-moz-column-rule-style": "column-rule-style",
                "-webkit-column-rule-style": "column-rule-style",

                "-moz-column-rule-color": "column-rule-color",
                "-webkit-column-rule-color": "column-rule-color",

                "-moz-column-rule-width": "column-rule-width",
                "-webkit-column-rule-width": "column-rule-width",

                "-moz-column-width": "column-width",
                "-webkit-column-width": "column-width",

                "-webkit-column-span": "column-span",
                "-webkit-columns": "columns",

                "-moz-box-shadow": "box-shadow",
                "-webkit-box-shadow": "box-shadow",

                "-moz-transform" : "transform",
                "-webkit-transform" : "transform",
                "-o-transform" : "transform",
                "-ms-transform" : "transform",

                "-moz-transform-origin" : "transform-origin",
                "-webkit-transform-origin" : "transform-origin",
                "-o-transform-origin" : "transform-origin",
                "-ms-transform-origin" : "transform-origin",

                "-moz-box-sizing" : "box-sizing",
                "-webkit-box-sizing" : "box-sizing",

                "-moz-user-select" : "user-select",
                "-khtml-user-select" : "user-select",
                "-webkit-user-select" : "user-select"
            };

        //event handler for beginning of rules
        function startRule(){
            properties = {};
            num=1;
        }

        //event handler for end of rules
        function endRule(event){
            var prop,
                i, len,
                standard,
                needed,
                actual,
                needsStandard = [];

            for (prop in properties){
                if (propertiesToCheck[prop]){
                    needsStandard.push({ actual: prop, needed: propertiesToCheck[prop]});
                }
            }

            for (i=0, len=needsStandard.length; i < len; i++){
                needed = needsStandard[i].needed;
                actual = needsStandard[i].actual;

                if (!properties[needed]){
                    reporter.report("Missing standard property '" + needed + "' to go along with '" + actual + "'.", properties[actual][0].name.line, properties[actual][0].name.col, rule);
                } else {
                    //make sure standard property is last
                    if (properties[needed][0].pos < properties[actual][0].pos){
                        reporter.report("Standard property '" + needed + "' should come after vendor-prefixed property '" + actual + "'.", properties[actual][0].name.line, properties[actual][0].name.col, rule);
                    }
                }
            }

        }

        parser.addListener("startrule", startRule);
        parser.addListener("startfontface", startRule);
        parser.addListener("startpage", startRule);
        parser.addListener("startpagemargin", startRule);
        parser.addListener("startkeyframerule", startRule);

        parser.addListener("property", function(event){
            var name = event.property.text.toLowerCase();

            if (!properties[name]){
                properties[name] = [];
            }

            properties[name].push({ name: event.property, value : event.value, pos:num++ });
        });

        parser.addListener("endrule", endRule);
        parser.addListener("endfontface", endRule);
        parser.addListener("endpage", endRule);
        parser.addListener("endpagemargin", endRule);
        parser.addListener("endkeyframerule", endRule);
    }

});
/*
 * Rule: You don't need to specify units when a value is 0.
 */
/*global CSSLint*/
CSSLint.addRule({

    //rule information
    id: "zero-units",
    name: "Disallow units for 0 values",
    desc: "You don't need to specify units when a value is 0.",
    browsers: "All",

    //initialization
    init: function(parser, reporter){
        var rule = this;

        //count how many times "float" is used
        parser.addListener("property", function(event){
            var parts = event.value.parts,
                i = 0,
                len = parts.length;

            while(i < len){
                if ((parts[i].units || parts[i].type == "percentage") && parts[i].value === 0 && parts[i].type != "time"){
                    reporter.report("Values of 0 shouldn't have units specified.", parts[i].line, parts[i].col, rule);
                }
                i++;
            }

        });

    }

});
/*global CSSLint*/
(function() {

    /**
     * Replace special characters before write to output.
     *
     * Rules:
     *  - single quotes is the escape sequence for double-quotes
     *  - &amp; is the escape sequence for &
     *  - &lt; is the escape sequence for <
     *  - &gt; is the escape sequence for >
     *
     * @param {String} message to escape
     * @return escaped message as {String}
     */
    var xmlEscape = function(str) {
        if (!str || str.constructor !== String) {
            return "";
        }

        return str.replace(/[\"&><]/g, function(match) {
            switch (match) {
                case "\"":
                    return "&quot;";
                case "&":
                    return "&amp;";
                case "<":
                    return "&lt;";
                case ">":
                    return "&gt;";
            }
        });
    };

    CSSLint.addFormatter({
        //format information
        id: "checkstyle-xml",
        name: "Checkstyle XML format",

        /**
         * Return opening root XML tag.
         * @return {String} to prepend before all results
         */
        startFormat: function(){
            return "<?xml version=\"1.0\" encoding=\"utf-8\"?><checkstyle>";
        },

        /**
         * Return closing root XML tag.
         * @return {String} to append after all results
         */
        endFormat: function(){
            return "</checkstyle>";
        },

        /**
         * Returns message when there is a file read error.
         * @param {String} filename The name of the file that caused the error.
         * @param {String} message The error message
         * @return {String} The error message.
         */
        readError: function(filename, message) {
            return "<file name=\"" + xmlEscape(filename) + "\"><error line=\"0\" column=\"0\" severty=\"error\" message=\"" + xmlEscape(message) + "\"></error></file>";
        },

        /**
         * Given CSS Lint results for a file, return output for this format.
         * @param results {Object} with error and warning messages
         * @param filename {String} relative file path
         * @param options {Object} (UNUSED for now) specifies special handling of output
         * @return {String} output for results
         */
        formatResults: function(results, filename, options) {
            var messages = results.messages,
                output = [];

            /**
             * Generate a source string for a rule.
             * Checkstyle source strings usually resemble Java class names e.g
             * net.csslint.SomeRuleName
             * @param {Object} rule
             * @return rule source as {String}
             */
            var generateSource = function(rule) {
                if (!rule || !('name' in rule)) {
                    return "";
                }
                return 'net.csslint.' + rule.name.replace(/\s/g,'');
            };



            if (messages.length > 0) {
                output.push("<file name=\""+filename+"\">");
                CSSLint.Util.forEach(messages, function (message, i) {
                    //ignore rollups for now
                    if (!message.rollup) {
                      output.push("<error line=\"" + message.line + "\" column=\"" + message.col + "\" severity=\"" + message.type + "\"" +
                          " message=\"" + xmlEscape(message.message) + "\" source=\"" + generateSource(message.rule) +"\"/>");
                    }
                });
                output.push("</file>");
            }

            return output.join("");
        }
    });

}());
/*global CSSLint*/
CSSLint.addFormatter({
    //format information
    id: "compact",
    name: "Compact, 'porcelain' format",

    /**
     * Return content to be printed before all file results.
     * @return {String} to prepend before all results
     */
    startFormat: function() {
        return "";
    },

    /**
     * Return content to be printed after all file results.
     * @return {String} to append after all results
     */
    endFormat: function() {
        return "";
    },

    /**
     * Given CSS Lint results for a file, return output for this format.
     * @param results {Object} with error and warning messages
     * @param filename {String} relative file path
     * @param options {Object} (Optional) specifies special handling of output
     * @return {String} output for results
     */
    formatResults: function(results, filename, options) {
        var messages = results.messages,
            output = "";
        options = options || {};

        /**
         * Capitalize and return given string.
         * @param str {String} to capitalize
         * @return {String} capitalized
         */
        var capitalize = function(str) {
            return str.charAt(0).toUpperCase() + str.slice(1);
        };

        if (messages.length === 0) {
            return options.quiet ? "" : filename + ": Lint Free!";
        }

        CSSLint.Util.forEach(messages, function(message, i) {
            if (message.rollup) {
                output += filename + ": " + capitalize(message.type) + " - " + message.message + "\n";
            } else {
                output += filename + ": " + "line " + message.line +
                    ", col " + message.col + ", " + capitalize(message.type) + " - " + message.message + "\n";
            }
        });

        return output;
    }
});
/*global CSSLint*/
CSSLint.addFormatter({
    //format information
    id: "csslint-xml",
    name: "CSSLint XML format",

    /**
     * Return opening root XML tag.
     * @return {String} to prepend before all results
     */
    startFormat: function(){
        return "<?xml version=\"1.0\" encoding=\"utf-8\"?><csslint>";
    },

    /**
     * Return closing root XML tag.
     * @return {String} to append after all results
     */
    endFormat: function(){
        return "</csslint>";
    },

    /**
     * Given CSS Lint results for a file, return output for this format.
     * @param results {Object} with error and warning messages
     * @param filename {String} relative file path
     * @param options {Object} (UNUSED for now) specifies special handling of output
     * @return {String} output for results
     */
    formatResults: function(results, filename, options) {
        var messages = results.messages,
            output = [];

        /**
         * Replace special characters before write to output.
         *
         * Rules:
         *  - single quotes is the escape sequence for double-quotes
         *  - &amp; is the escape sequence for &
         *  - &lt; is the escape sequence for <
         *  - &gt; is the escape sequence for >
         *
         * @param {String} message to escape
         * @return escaped message as {String}
         */
        var escapeSpecialCharacters = function(str) {
            if (!str || str.constructor !== String) {
                return "";
            }
            return str.replace(/\"/g, "'").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
        };

        if (messages.length > 0) {
            output.push("<file name=\""+filename+"\">");
            CSSLint.Util.forEach(messages, function (message, i) {
                if (message.rollup) {
                    output.push("<issue severity=\"" + message.type + "\" reason=\"" + escapeSpecialCharacters(message.message) + "\" evidence=\"" + escapeSpecialCharacters(message.evidence) + "\"/>");
                } else {
                    output.push("<issue line=\"" + message.line + "\" char=\"" + message.col + "\" severity=\"" + message.type + "\"" +
                        " reason=\"" + escapeSpecialCharacters(message.message) + "\" evidence=\"" + escapeSpecialCharacters(message.evidence) + "\"/>");
                }
            });
            output.push("</file>");
        }

        return output.join("");
    }
});
/*global CSSLint*/
CSSLint.addFormatter({
    //format information
    id: "junit-xml",
    name: "JUNIT XML format",

    /**
     * Return opening root XML tag.
     * @return {String} to prepend before all results
     */
    startFormat: function(){
        return "<?xml version=\"1.0\" encoding=\"utf-8\"?><testsuites>";
    },

    /**
     * Return closing root XML tag.
     * @return {String} to append after all results
     */
    endFormat: function() {
        return "</testsuites>";
    },

    /**
     * Given CSS Lint results for a file, return output for this format.
     * @param results {Object} with error and warning messages
     * @param filename {String} relative file path
     * @param options {Object} (UNUSED for now) specifies special handling of output
     * @return {String} output for results
     */
    formatResults: function(results, filename, options) {

        var messages = results.messages,
            output = [],
            tests = {
                'error': 0,
                'failure': 0
            };

        /**
         * Generate a source string for a rule.
         * JUNIT source strings usually resemble Java class names e.g
         * net.csslint.SomeRuleName
         * @param {Object} rule
         * @return rule source as {String}
         */
        var generateSource = function(rule) {
            if (!rule || !('name' in rule)) {
                return "";
            }
            return 'net.csslint.' + rule.name.replace(/\s/g,'');
        };

        /**
         * Replace special characters before write to output.
         *
         * Rules:
         *  - single quotes is the escape sequence for double-quotes
         *  - &lt; is the escape sequence for <
         *  - &gt; is the escape sequence for >
         *
         * @param {String} message to escape
         * @return escaped message as {String}
         */
        var escapeSpecialCharacters = function(str) {

            if (!str || str.constructor !== String) {
                return "";
            }

            return str.replace(/\"/g, "'").replace(/</g, "&lt;").replace(/>/g, "&gt;");

        };

        if (messages.length > 0) {

            messages.forEach(function (message, i) {

                // since junit has no warning class
                // all issues as errors
                var type = message.type === 'warning' ? 'error' : message.type;

                //ignore rollups for now
                if (!message.rollup) {

                    // build the test case seperately, once joined
                    // we'll add it to a custom array filtered by type
                    output.push("<testcase time=\"0\" name=\"" + generateSource(message.rule) + "\">");
                    output.push("<" + type + " message=\"" + escapeSpecialCharacters(message.message) + "\"><![CDATA[" + message.line + ':' + message.col + ':' + escapeSpecialCharacters(message.evidence)  + "]]></" + type + ">");
                    output.push("</testcase>");

                    tests[type] += 1;

                }

            });

            output.unshift("<testsuite time=\"0\" tests=\"" + messages.length + "\" skipped=\"0\" errors=\"" + tests.error + "\" failures=\"" + tests.failure + "\" package=\"net.csslint\" name=\"" + filename + "\">");
            output.push("</testsuite>");

        }

        return output.join("");

    }
});
/*global CSSLint*/
CSSLint.addFormatter({
    //format information
    id: "lint-xml",
    name: "Lint XML format",

    /**
     * Return opening root XML tag.
     * @return {String} to prepend before all results
     */
    startFormat: function(){
        return "<?xml version=\"1.0\" encoding=\"utf-8\"?><lint>";
    },

    /**
     * Return closing root XML tag.
     * @return {String} to append after all results
     */
    endFormat: function(){
        return "</lint>";
    },

    /**
     * Given CSS Lint results for a file, return output for this format.
     * @param results {Object} with error and warning messages
     * @param filename {String} relative file path
     * @param options {Object} (UNUSED for now) specifies special handling of output
     * @return {String} output for results
     */
    formatResults: function(results, filename, options) {
        var messages = results.messages,
            output = [];

        /**
         * Replace special characters before write to output.
         *
         * Rules:
         *  - single quotes is the escape sequence for double-quotes
         *  - &amp; is the escape sequence for &
         *  - &lt; is the escape sequence for <
         *  - &gt; is the escape sequence for >
         *
         * @param {String} message to escape
         * @return escaped message as {String}
         */
        var escapeSpecialCharacters = function(str) {
            if (!str || str.constructor !== String) {
                return "";
            }
            return str.replace(/\"/g, "'").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
        };

        if (messages.length > 0) {

            output.push("<file name=\""+filename+"\">");
            CSSLint.Util.forEach(messages, function (message, i) {
                if (message.rollup) {
                    output.push("<issue severity=\"" + message.type + "\" reason=\"" + escapeSpecialCharacters(message.message) + "\" evidence=\"" + escapeSpecialCharacters(message.evidence) + "\"/>");
                } else {
                    output.push("<issue line=\"" + message.line + "\" char=\"" + message.col + "\" severity=\"" + message.type + "\"" +
                        " reason=\"" + escapeSpecialCharacters(message.message) + "\" evidence=\"" + escapeSpecialCharacters(message.evidence) + "\"/>");
                }
            });
            output.push("</file>");
        }

        return output.join("");
    }
});
/*global CSSLint*/
CSSLint.addFormatter({
    //format information
    id: "text",
    name: "Plain Text",

    /**
     * Return content to be printed before all file results.
     * @return {String} to prepend before all results
     */
    startFormat: function() {
        return "";
    },

    /**
     * Return content to be printed after all file results.
     * @return {String} to append after all results
     */
    endFormat: function() {
        return "";
    },

    /**
     * Given CSS Lint results for a file, return output for this format.
     * @param results {Object} with error and warning messages
     * @param filename {String} relative file path
     * @param options {Object} (Optional) specifies special handling of output
     * @return {String} output for results
     */
    formatResults: function(results, filename, options) {
        var messages = results.messages,
            output = "";
        options = options || {};

        if (messages.length === 0) {
            return options.quiet ? "" : "\n\ncsslint: No errors in " + filename + ".";
        }

        output = "\n\ncsslint: There are " + messages.length  +  " problems in " + filename + ".";
        var pos = filename.lastIndexOf("/"),
            shortFilename = filename;

        if (pos === -1){
            pos = filename.lastIndexOf("\\");
        }
        if (pos > -1){
            shortFilename = filename.substring(pos+1);
        }

        CSSLint.Util.forEach(messages, function (message, i) {
            output = output + "\n\n" + shortFilename;
            if (message.rollup) {
                output += "\n" + (i+1) + ": " + message.type;
                output += "\n" + message.message;
            } else {
                output += "\n" + (i+1) + ": " + message.type + " at line " + message.line + ", col " + message.col;
                output += "\n" + message.message;
                output += "\n" + message.evidence;
            }
        });

        return output;
    }
});
exports.CSSLint = CSSLint;


================================================
FILE: gulp/util/csslint/lib/parserlib.js
================================================
/*!
Parser-Lib
Copyright (c) 2009-2011 Nicholas C. Zakas. All rights reserved.

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.

*/
/* Version v0.2.5, Build time: 7-May-2014 03:37:38 */
var parserlib = {};
(function(){

/**
 * A generic base to inherit from for any object
 * that needs event handling.
 * @class EventTarget
 * @constructor
 */
function EventTarget(){

    /**
     * The array of listeners for various events.
     * @type Object
     * @property _listeners
     * @private
     */
    this._listeners = {};
}

EventTarget.prototype = {

    //restore constructor
    constructor: EventTarget,

    /**
     * Adds a listener for a given event type.
     * @param {String} type The type of event to add a listener for.
     * @param {Function} listener The function to call when the event occurs.
     * @return {void}
     * @method addListener
     */
    addListener: function(type, listener){
        if (!this._listeners[type]){
            this._listeners[type] = [];
        }

        this._listeners[type].push(listener);
    },

    /**
     * Fires an event based on the passed-in object.
     * @param {Object|String} event An object with at least a 'type' attribute
     *      or a string indicating the event name.
     * @return {void}
     * @method fire
     */
    fire: function(event){
        if (typeof event == "string"){
            event = { type: event };
        }
        if (typeof event.target != "undefined"){
            event.target = this;
        }

        if (typeof event.type == "undefined"){
            throw new Error("Event object missing 'type' property.");
        }

        if (this._listeners[event.type]){

            //create a copy of the array and use that so listeners can't chane
            var listeners = this._listeners[event.type].concat();
            for (var i=0, len=listeners.length; i < len; i++){
                listeners[i].call(this, event);
            }
        }
    },

    /**
     * Removes a listener for a given event type.
     * @param {String} type The type of event to remove a listener from.
     * @param {Function} listener The function to remove from the event.
     * @return {void}
     * @method removeListener
     */
    removeListener: function(type, listener){
        if (this._listeners[type]){
            var listeners = this._listeners[type];
            for (var i=0, len=listeners.length; i < len; i++){
                if (listeners[i] === listener){
                    listeners.splice(i, 1);
                    break;
                }
            }


        }
    }
};
/**
 * Convenient way to read through strings.
 * @namespace parserlib.util
 * @class StringReader
 * @constructor
 * @param {String} text The text to read.
 */
function StringReader(text){

    /**
     * The input text with line endings normalized.
     * @property _input
     * @type String
     * @private
     */
    this._input = text.replace(/\n\r?/g, "\n");


    /**
     * The row for the character to be read next.
     * @property _line
     * @type int
     * @private
     */
    this._line = 1;


    /**
     * The column for the character to be read next.
     * @property _col
     * @type int
     * @private
     */
    this._col = 1;

    /**
     * The index of the character in the input to be read next.
     * @property _cursor
     * @type int
     * @private
     */
    this._cursor = 0;
}

StringReader.prototype = {

    //restore constructor
    constructor: StringReader,

    //-------------------------------------------------------------------------
    // Position info
    //-------------------------------------------------------------------------

    /**
     * Returns the column of the character to be read next.
     * @return {int} The column of the character to be read next.
     * @method getCol
     */
    getCol: function(){
        return this._col;
    },

    /**
     * Returns the row of the character to be read next.
     * @return {int} The row of the character to be read next.
     * @method getLine
     */
    getLine: function(){
        return this._line ;
    },

    /**
     * Determines if you're at the end of the input.
     * @return {Boolean} True if there's no more input, false otherwise.
     * @method eof
     */
    eof: function(){
        return (this._cursor == this._input.length);
    },

    //-------------------------------------------------------------------------
    // Basic reading
    //-------------------------------------------------------------------------

    /**
     * Reads the next character without advancing the cursor.
     * @param {int} count How many characters to look ahead (default is 1).
     * @return {String} The next character or null if there is no next character.
     * @method peek
     */
    peek: function(count){
        var c = null;
        count = (typeof count == "undefined" ? 1 : count);

        //if we're not at the end of the input...
        if (this._cursor < this._input.length){

            //get character and increment cursor and column
            c = this._input.charAt(this._cursor + count - 1);
        }

        return c;
    },

    /**
     * Reads the next character from the input and adjusts the row and column
     * accordingly.
     * @return {String} The next character or null if there is no next character.
     * @method read
     */
    read: function(){
        var c = null;

        //if we're not at the end of the input...
        if (this._cursor < this._input.length){

            //if the last character was a newline, increment row count
            //and reset column count
            if (this._input.charAt(this._cursor) == "\n"){
                this._line++;
                this._col=1;
            } else {
                this._col++;
            }

            //get character and increment cursor and column
            c = this._input.charAt(this._cursor++);
        }

        return c;
    },

    //-------------------------------------------------------------------------
    // Misc
    //-------------------------------------------------------------------------

    /**
     * Saves the current location so it can be returned to later.
     * @method mark
     * @return {void}
     */
    mark: function(){
        this._bookmark = {
            cursor: this._cursor,
            line:   this._line,
            col:    this._col
        };
    },

    reset: function(){
        if (this._bookmark){
            this._cursor = this._bookmark.cursor;
            this._line = this._bookmark.line;
            this._col = this._bookmark.col;
            delete this._bookmark;
        }
    },

    //-------------------------------------------------------------------------
    // Advanced reading
    //-------------------------------------------------------------------------

    /**
     * Reads up to and including the given string. Throws an error if that
     * string is not found.
     * @param {String} pattern The string to read.
     * @return {String} The string when it is found.
     * @throws Error when the string pattern is not found.
     * @method readTo
     */
    readTo: function(pattern){

        var buffer = "",
            c;

        /*
         * First, buffer must be the same length as the pattern.
         * Then, buffer must end with the pattern or else reach the
         * end of the input.
         */
        while (buffer.length < pattern.length || buffer.lastIndexOf(pattern) != buffer.length - pattern.length){
            c = this.read();
            if (c){
                buffer += c;
            } else {
                throw new Error("Expected \"" + pattern + "\" at line " + this._line  + ", col " + this._col + ".");
            }
        }

        return buffer;

    },

    /**
     * Reads characters while each character causes the given
     * filter function to return true. The function is passed
     * in each character and either returns true to continue
     * reading or false to stop.
     * @param {Function} filter The function to read on each character.
     * @return {String} The string made up of all characters that passed the
     *      filter check.
     * @method readWhile
     */
    readWhile: function(filter){

        var buffer = "",
            c = this.read();

        while(c !== null && filter(c)){
            buffer += c;
            c = this.read();
        }

        return buffer;

    },

    /**
     * Reads characters that match either text or a regular expression and
     * returns those characters. If a match is found, the row and column
     * are adjusted; if no match is found, the reader's state is unchanged.
     * reading or false to stop.
     * @param {String|RegExp} matchter If a string, then the literal string
     *      value is searched for. If a regular expression, then any string
     *      matching the pattern is search for.
     * @return {String} The string made up of all characters that matched or
     *      null if there was no match.
     * @method readMatch
     */
    readMatch: function(matcher){

        var source = this._input.substring(this._cursor),
            value = null;

        //if it's a string, just do a straight match
        if (typeof matcher == "string"){
            if (source.indexOf(matcher) === 0){
                value = this.readCount(matcher.length);
            }
        } else if (matcher instanceof RegExp){
            if (matcher.test(source)){
                value = this.readCount(RegExp.lastMatch.length);
            }
        }

        return value;
    },


    /**
     * Reads a given number of characters. If the end of the input is reached,
     * it reads only the remaining characters and does not throw an error.
     * @param {int} count The number of characters to read.
     * @return {String} The string made up the read characters.
     * @method readCount
     */
    readCount: function(count){
        var buffer = "";

        while(count--){
            buffer += this.read();
        }

        return buffer;
    }

};
/**
 * Type to use when a syntax error occurs.
 * @class SyntaxError
 * @namespace parserlib.util
 * @constructor
 * @param {String} message The error message.
 * @param {int} line The line at which the error occurred.
 * @param {int} col The column at which the error occurred.
 */
function SyntaxError(message, line, col){

    /**
     * The column at which the error occurred.
     * @type int
     * @property col
     */
    this.col = col;

    /**
     * The line at which the error occurred.
     * @type int
     * @property line
     */
    this.line = line;

    /**
     * The text representation of the unit.
     * @type String
     * @property text
     */
    this.message = message;

}

//inherit from Error
SyntaxError.prototype = new Error();
/**
 * Base type to represent a single syntactic unit.
 * @class SyntaxUnit
 * @namespace parserlib.util
 * @constructor
 * @param {String} text The text of the unit.
 * @param {int} line The line of text on which the unit resides.
 * @param {int} col The column of text on which the unit resides.
 */
function SyntaxUnit(text, line, col, type){


    /**
     * The column of text on which the unit resides.
     * @type int
     * @property col
     */
    this.col = col;

    /**
     * The line of text on which the unit resides.
     * @type int
     * @property line
     */
    this.line = line;

    /**
     * The text representation of the unit.
     * @type String
     * @property text
     */
    this.text = text;

    /**
     * The type of syntax unit.
     * @type int
     * @property type
     */
    this.type = type;
}

/**
 * Create a new syntax unit based solely on the given token.
 * Convenience method for creating a new syntax unit when
 * it represents a single token instead of multiple.
 * @param {Object} token The token object to represent.
 * @return {parserlib.util.SyntaxUnit} The object representing the token.
 * @static
 * @method fromToken
 */
SyntaxUnit.fromToken = function(token){
    return new SyntaxUnit(token.value, token.startLine, token.startCol);
};

SyntaxUnit.prototype = {

    //restore constructor
    constructor: SyntaxUnit,

    /**
     * Returns the text representation of the unit.
     * @return {String} The text representation of the unit.
     * @method valueOf
     */
    valueOf: function(){
        return this.toString();
    },

    /**
     * Returns the text representation of the unit.
     * @return {String} The text representation of the unit.
     * @method toString
     */
    toString: function(){
        return this.text;
    }

};
/*global StringReader, SyntaxError*/

/**
 * Generic TokenStream providing base functionality.
 * @class TokenStreamBase
 * @namespace parserlib.util
 * @constructor
 * @param {String|StringReader} input The text to tokenize or a reader from
 *      which to read the input.
 */
function TokenStreamBase(input, tokenData){

    /**
     * The string reader for easy access to the text.
     * @type StringReader
     * @property _reader
     * @private
     */
    this._reader = input ? new StringReader(input.toString()) : null;

    /**
     * Token object for the last consumed token.
     * @type Token
     * @property _token
     * @private
     */
    this._token = null;

    /**
     * The array of token information.
     * @type Array
     * @property _tokenData
     * @private
     */
    this._tokenData = tokenData;

    /**
     * Lookahead token buffer.
     * @type Array
     * @property _lt
     * @private
     */
    this._lt = [];

    /**
     * Lookahead token buffer index.
     * @type int
     * @property _ltIndex
     * @private
     */
    this._ltIndex = 0;

    this._ltIndexCache = [];
}

/**
 * Accepts an array of token information and outputs
 * an array of token data containing key-value mappings
 * and matching functions that the TokenStream needs.
 * @param {Array} tokens An array of token descriptors.
 * @return {Array} An array of processed token data.
 * @method createTokenData
 * @static
 */
TokenStreamBase.createTokenData = function(tokens){

    var nameMap     = [],
        typeMap     = {},
        tokenData     = tokens.concat([]),
        i            = 0,
        len            = tokenData.length+1;

    tokenData.UNKNOWN = -1;
    tokenData.unshift({name:"EOF"});

    for (; i < len; i++){
        nameMap.push(tokenData[i].name);
        tokenData[tokenData[i].name] = i;
        if (tokenData[i].text){
            typeMap[tokenData[i].text] = i;
        }
    }

    tokenData.name = function(tt){
        return nameMap[tt];
    };

    tokenData.type = function(c){
        return typeMap[c];
    };

    return tokenData;
};

TokenStreamBase.prototype = {

    //restore constructor
    constructor: TokenStreamBase,

    //-------------------------------------------------------------------------
    // Matching methods
    //-------------------------------------------------------------------------

    /**
     * Determines if the next token matches the given token type.
     * If so, that token is consumed; if not, the token is placed
     * back onto the token stream. You can pass in any number of
     * token types and this will return true if any of the token
     * types is found.
     * @param {int|int[]} tokenTypes Either a single token type or an array of
     *      token types that the next token might be. If an array is passed,
     *      it's assumed that the token can be any of these.
     * @param {variant} channel (Optional) The channel to read from. If not
     *      provided, reads from the default (unnamed) channel.
     * @return {Boolean} True if the token type matches, false if not.
     * @method match
     */
    match: function(tokenTypes, channel){

        //always convert to an array, makes things easier
        if (!(tokenTypes instanceof Array)){
            tokenTypes = [tokenTypes];
        }

        var tt  = this.get(channel),
            i   = 0,
            len = tokenTypes.length;

        while(i < len){
            if (tt == tokenTypes[i++]){
                return true;
            }
        }

        //no match found, put the token back
        this.unget();
        return false;
    },

    /**
     * Determines if the next token matches the given token type.
     * If so, that token is consumed; if not, an error is thrown.
     * @param {int|int[]} tokenTypes Either a single token type or an array of
     *      token types that the next token should be. If an array is passed,
     *      it's assumed that the token must be one of these.
     * @param {variant} channel (Optional) The channel to read from. If not
     *      provided, reads from the default (unnamed) channel.
     * @return {void}
     * @method mustMatch
     */
    mustMatch: function(tokenTypes, channel){

        var token;

        //always convert to an array, makes things easier
        if (!(tokenTypes instanceof Array)){
            tokenTypes = [tokenTypes];
        }

        if (!this.match.apply(this, arguments)){
            token = this.LT(1);
            throw new SyntaxError("Expected " + this._tokenData[tokenTypes[0]].name +
                " at line " + token.startLine + ", col " + token.startCol + ".", token.startLine, token.startCol);
        }
    },

    //-------------------------------------------------------------------------
    // Consuming methods
    //-------------------------------------------------------------------------

    /**
     * Keeps reading from the token stream until either one of the specified
     * token types is found or until the end of the input is reached.
     * @param {int|int[]} tokenTypes Either a single token type or an array of
     *      token types that the next token should be. If an array is passed,
     *      it's assumed that the token must be one of these.
     * @param {variant} channel (Optional) The channel to read from. If not
     *      provided, reads from the default (unnamed) channel.
     * @return {void}
     * @method advance
     */
    advance: function(tokenTypes, channel){

        while(this.LA(0) !== 0 && !this.match(tokenTypes, channel)){
            this.get();
        }

        return this.LA(0);
    },

    /**
     * Consumes the next token from the token stream.
     * @return {int} The token type of the token that was just consumed.
     * @method get
     */
    get: function(channel){

        var tokenInfo   = this._tokenData,
            reader      = this._reader,
            value,
            i           =0,
            len         = tokenInfo.length,
            found       = false,
            token,
            info;

        //check the lookahead buffer first
        if (this._lt.length && this._ltIndex >= 0 && this._ltIndex < this._lt.length){

            i++;
            this._token = this._lt[this._ltIndex++];
            info = tokenInfo[this._token.type];

            //obey channels logic
            while((info.channel !== undefined && channel !== info.channel) &&
                    this._ltIndex < this._lt.length){
                this._token = this._lt[this._ltIndex++];
                info = tokenInfo[this._token.type];
                i++;
            }

            //here be dragons
            if ((info.channel === undefined || channel === info.channel) &&
                    this._ltIndex <= this._lt.length){
                this._ltIndexCache.push(i);
                return this._token.type;
            }
        }

        //call token retriever method
        token = this._getToken();

        //if it should be hidden, don't save a token
        if (token.type > -1 && !tokenInfo[token.type].hide){

            //apply token channel
            token.channel = tokenInfo[token.type].channel;

            //save for later
            this._token = token;
            this._lt.push(token);

            //save space that will be moved (must be done before array is truncated)
            this._ltIndexCache.push(this._lt.length - this._ltIndex + i);

            //keep the buffer under 5 items
            if (this._lt.length > 5){
                this._lt.shift();
            }

            //also keep the shift buffer under 5 items
            if (this._ltIndexCache.length > 5){
                this._ltIndexCache.shift();
            }

            //update lookahead index
            this._ltIndex = this._lt.length;
        }

        /*
         * Skip to the next token if:
         * 1. The token type is marked as hidden.
         * 2. The token type has a channel specified and it isn't the current channel.
         */
        info = tokenInfo[token.type];
        if (info &&
                (info.hide ||
                (info.channel !== undefined && channel !== info.channel))){
            return this.get(channel);
        } else {
            //return just the type
            return token.type;
        }
    },

    /**
     * Looks ahead a certain number of tokens and returns the token type at
     * that position. This will throw an error if you lookahead past the
     * end of input, past the size of the lookahead buffer, or back past
     * the first token in the lookahead buffer.
     * @param {int} The index of the token type to retrieve. 0 for the
     *      current token, 1 for the next, -1 for the previous, etc.
     * @return {int} The token type of the token in the given position.
     * @method LA
     */
    LA: function(index){
        var total = index,
            tt;
        if (index > 0){
            //TODO: Store 5 somewhere
            if (index > 5){
                throw new Error("Too much lookahead.");
            }

            //get all those tokens
            while(total){
                tt = this.get();
                total--;
            }

            //unget all those tokens
            while(total < index){
                this.unget();
                total++;
            }
        } else if (index < 0){

            if(this._lt[this._ltIndex+index]){
                tt = this._lt[this._ltIndex+index].type;
            } else {
                throw new Error("Too much lookbehind.");
            }

        } else {
            tt = this._token.type;
        }

        return tt;

    },

    /**
     * Looks ahead a certain number of tokens and returns the token at
     * that position. This will throw an error if you lookahead past the
     * end of input, past the size of the lookahead buffer, or back past
     * the first token in the lookahead buffer.
     * @param {int} The index of the token type to retrieve. 0 for the
     *      current token, 1 for the next, -1 for the previous, etc.
     * @return {Object} The token of the token in the given position.
     * @method LA
     */
    LT: function(index){

        //lookahead first to prime the token buffer
        this.LA(index);

        //now find the token, subtract one because _ltIndex is already at the next index
        return this._lt[this._ltIndex+index-1];
    },

    /**
     * Returns the token type for the next token in the stream without
     * consuming it.
     * @return {int} The token type of the next token in the stream.
     * @method peek
     */
    peek: function(){
        return this.LA(1);
    },

    /**
     * Returns the actual token object for the last consumed token.
     * @return {Token} The token object for the last consumed token.
     * @method token
     */
    token: function(){
        return this._token;
    },

    /**
     * Returns the name of the token for the given token type.
     * @param {int} tokenType The type of token to get the name of.
     * @return {String} The name of the token or "UNKNOWN_TOKEN" for any
     *      invalid token type.
     * @method tokenName
     */
    tokenName: function(tokenType){
        if (tokenType < 0 || tokenType > this._tokenData.length){
            return "UNKNOWN_TOKEN";
        } else {
            return this._tokenData[tokenType].name;
        }
    },

    /**
     * Returns the token type value for the given token name.
     * @param {String} tokenName The name of the token whose value should be returned.
     * @return {int} The token type value for the given token name or -1
     *      for an unknown token.
     * @method tokenName
     */
    tokenType: function(tokenName){
        return this._tokenData[tokenName] || -1;
    },

    /**
     * Returns the last consumed token to the token stream.
     * @method unget
     */
    unget: function(){
        //if (this._ltIndex > -1){
        if (this._ltIndexCache.length){
            this._ltIndex -= this._ltIndexCache.pop();//--;
            this._token = this._lt[this._ltIndex - 1];
        } else {
            throw new Error("Too much lookahead.");
        }
    }

};


parserlib.util = {
StringReader: StringReader,
SyntaxError : SyntaxError,
SyntaxUnit  : SyntaxUnit,
EventTarget : EventTarget,
TokenStreamBase : TokenStreamBase
};
})();
/*
Parser-Lib
Copyright (c) 2009-2011 Nicholas C. Zakas. All rights reserved.

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.

*/
/* Version v0.2.5, Build time: 7-May-2014 03:37:38 */
(function(){
var EventTarget = parserlib.util.EventTarget,
TokenStreamBase = parserlib.util.TokenStreamBase,
StringReader = parserlib.util.StringReader,
SyntaxError = parserlib.util.SyntaxError,
SyntaxUnit  = parserlib.util.SyntaxUnit;

var Colors = {
    aliceblue       :"#f0f8ff",
    antiquewhite    :"#faebd7",
    aqua            :"#00ffff",
    aquamarine      :"#7fffd4",
    azure           :"#f0ffff",
    beige           :"#f5f5dc",
    bisque          :"#ffe4c4",
    black           :"#000000",
    blanchedalmond  :"#ffebcd",
    blue            :"#0000ff",
    blueviolet      :"#8a2be2",
    brown           :"#a52a2a",
    burlywood       :"#deb887",
    cadetblue       :"#5f9ea0",
    chartreuse      :"#7fff00",
    chocolate       :"#d2691e",
    coral           :"#ff7f50",
    cornflowerblue  :"#6495ed",
    cornsilk        :"#fff8dc",
    crimson         :"#dc143c",
    cyan            :"#00ffff",
    darkblue        :"#00008b",
    darkcyan        :"#008b8b",
    darkgoldenrod   :"#b8860b",
    darkgray        :"#a9a9a9",
    darkgrey        :"#a9a9a9",
    darkgreen       :"#006400",
    darkkhaki       :"#bdb76b",
    darkmagenta     :"#8b008b",
    darkolivegreen  :"#556b2f",
    darkorange      :"#ff8c00",
    darkorchid      :"#9932cc",
    darkred         :"#8b0000",
    darksalmon      :"#e9967a",
    darkseagreen    :"#8fbc8f",
    darkslateblue   :"#483d8b",
    darkslategray   :"#2f4f4f",
    darkslategrey   :"#2f4f4f",
    darkturquoise   :"#00ced1",
    darkviolet      :"#9400d3",
    deeppink        :"#ff1493",
    deepskyblue     :"#00bfff",
    dimgray         :"#696969",
    dimgrey         :"#696969",
    dodgerblue      :"#1e90ff",
    firebrick       :"#b22222",
    floralwhite     :"#fffaf0",
    forestgreen     :"#228b22",
    fuchsia         :"#ff00ff",
    gainsboro       :"#dcdcdc",
    ghostwhite      :"#f8f8ff",
    gold            :"#ffd700",
    goldenrod       :"#daa520",
    gray            :"#808080",
    grey            :"#808080",
    green           :"#008000",
    greenyellow     :"#adff2f",
    honeydew        :"#f0fff0",
    hotpink         :"#ff69b4",
    indianred       :"#cd5c5c",
    indigo          :"#4b0082",
    ivory           :"#fffff0",
    khaki           :"#f0e68c",
    lavender        :"#e6e6fa",
    lavenderblush   :"#fff0f5",
    lawngreen       :"#7cfc00",
    lemonchiffon    :"#fffacd",
    lightblue       :"#add8e6",
    lightcoral      :"#f08080",
    lightcyan       :"#e0ffff",
    lightgoldenrodyellow  :"#fafad2",
    lightgray       :"#d3d3d3",
    lightgrey       :"#d3d3d3",
    lightgreen      :"#90ee90",
    lightpink       :"#ffb6c1",
    lightsalmon     :"#ffa07a",
    lightseagreen   :"#20b2aa",
    lightskyblue    :"#87cefa",
    lightslategray  :"#778899",
    lightslategrey  :"#778899",
    lightsteelblue  :"#b0c4de",
    lightyellow     :"#ffffe0",
    lime            :"#00ff00",
    limegreen       :"#32cd32",
    linen           :"#faf0e6",
    magenta         :"#ff00ff",
    maroon          :"#800000",
    mediumaquamarine:"#66cdaa",
    mediumblue      :"#0000cd",
    mediumorchid    :"#ba55d3",
    mediumpurple    :"#9370d8",
    mediumseagreen  :"#3cb371",
    mediumslateblue :"#7b68ee",
    mediumspringgreen   :"#00fa9a",
    mediumturquoise :"#48d1cc",
    mediumvioletred :"#c71585",
    midnightblue    :"#191970",
    mintcream       :"#f5fffa",
    mistyrose       :"#ffe4e1",
    moccasin        :"#ffe4b5",
    navajowhite     :"#ffdead",
    navy            :"#000080",
    oldlace         :"#fdf5e6",
    olive           :"#808000",
    olivedrab       :"#6b8e23",
    orange          :"#ffa500",
    orangered       :"#ff4500",
    orchid          :"#da70d6",
    palegoldenrod   :"#eee8aa",
    palegreen       :"#98fb98",
    paleturquoise   :"#afeeee",
    palevioletred   :"#d87093",
    papayawhip      :"#ffefd5",
    peachpuff       :"#ffdab9",
    peru            :"#cd853f",
    pink            :"#ffc0cb",
    plum            :"#dda0dd",
    powderblue      :"#b0e0e6",
    purple          :"#800080",
    red             :"#ff0000",
    rosybrown       :"#bc8f8f",
    royalblue       :"#4169e1",
    saddlebrown     :"#8b4513",
    salmon          :"#fa8072",
    sandybrown      :"#f4a460",
    seagreen        :"#2e8b57",
    seashell        :"#fff5ee",
    sienna          :"#a0522d",
    silver          :"#c0c0c0",
    skyblue         :"#87ceeb",
    slateblue       :"#6a5acd",
    slategray       :"#708090",
    slategrey       :"#708090",
    snow            :"#fffafa",
    springgreen     :"#00ff7f",
    steelblue       :"#4682b4",
    tan             :"#d2b48c",
    teal            :"#008080",
    thistle         :"#d8bfd8",
    tomato          :"#ff6347",
    turquoise       :"#40e0d0",
    violet          :"#ee82ee",
    wheat           :"#f5deb3",
    white           :"#ffffff",
    whitesmoke      :"#f5f5f5",
    yellow          :"#ffff00",
    yellowgreen     :"#9acd32",
    //CSS2 system colors http://www.w3.org/TR/css3-color/#css2-system
    activeBorder        :"Active window border.",
    activecaption       :"Active window caption.",
    appworkspace        :"Background color of multiple document interface.",
    background          :"Desktop background.",
    buttonface          :"The face background color for 3-D elements that appear 3-D due to one layer of surrounding border.",
    buttonhighlight     :"The color of the border facing the light source for 3-D elements that appear 3-D due to one layer of surrounding border.",
    buttonshadow        :"The color of the border away from the light source for 3-D elements that appear 3-D due to one layer of surrounding border.",
    buttontext          :"Text on push buttons.",
    captiontext         :"Text in caption, size box, and scrollbar arrow box.",
    graytext            :"Grayed (disabled) text. This color is set to #000 if the current display driver does not support a solid gray color.",
    greytext            :"Greyed (disabled) text. This color is set to #000 if the current display driver does not support a solid grey color.",
    highlight           :"Item(s) selected in a control.",
    highlighttext       :"Text of item(s) selected in a control.",
    inactiveborder      :"Inactive window border.",
    inactivecaption     :"Inactive window caption.",
    inactivecaptiontext :"Color of text in an inactive caption.",
    infobackground      :"Background color for tooltip controls.",
    infotext            :"Text color for tooltip controls.",
    menu                :"Menu background.",
    menutext            :"Text in menus.",
    scrollbar           :"Scroll bar gray area.",
    threeddarkshadow    :"The color of the darker (generally outer) of the two borders away from the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border.",
    threedface          :"The face background color for 3-D elements that appear 3-D due to two concentric layers of surrounding border.",
    threedhighlight     :"The color of the lighter (generally outer) of the two borders facing the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border.",
    threedlightshadow   :"The color of the darker (generally inner) of the two borders facing the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border.",
    threedshadow        :"The color of the lighter (generally inner) of the two borders away from the light source for 3-D elements that appear 3-D due to two concentric layers of surrounding border.",
    window              :"Window background.",
    windowframe         :"Window frame.",
    windowtext          :"Text in windows."
};
/*global SyntaxUnit, Parser*/
/**
 * Represents a selector combinator (whitespace, +, >).
 * @namespace parserlib.css
 * @class Combinator
 * @extends parserlib.util.SyntaxUnit
 * @constructor
 * @param {String} text The text representation of the unit.
 * @param {int} line The line of text on which the unit resides.
 * @param {int} col The column of text on which the unit resides.
 */
function Combinator(text, line, col){

    SyntaxUnit.call(this, text, line, col, Parser.COMBINATOR_TYPE);

    /**
     * The type of modifier.
     * @type String
     * @property type
     */
    this.type = "unknown";

    //pretty simple
    if (/^\s+$/.test(text)){
        this.type = "descendant";
    } else if (text == ">"){
        this.type = "child";
    } else if (text == "+"){
        this.type = "adjacent-sibling";
    } else if (text == "~"){
        this.type = "sibling";
    }

}

Combinator.prototype = new SyntaxUnit();
Combinator.prototype.constructor = Combinator;

/*global SyntaxUnit, Parser*/
/**
 * Represents a media feature, such as max-width:500.
 * @namespace parserlib.css
 * @class MediaFeature
 * @extends parserlib.util.SyntaxUnit
 * @constructor
 * @param {SyntaxUnit} name The name of the feature.
 * @param {SyntaxUnit} value The value of the feature or null if none.
 */
function MediaFeature(name, value){

    SyntaxUnit.call(this, "(" + name + (value !== null ? ":" + value : "") + ")", name.startLine, name.startCol, Parser.MEDIA_FEATURE_TYPE);

    /**
     * The name of the media feature
     * @type String
     * @property name
     */
    this.name = name;

    /**
     * The value for the feature or null if there is none.
     * @type SyntaxUnit
     * @property value
     */
    this.value = value;
}

MediaFeature.prototype = new SyntaxUnit();
MediaFeature.prototype.constructor = MediaFeature;

/*global SyntaxUnit, Parser*/
/**
 * Represents an individual media query.
 * @namespace parserlib.css
 * @class MediaQuery
 * @extends parserlib.util.SyntaxUnit
 * @constructor
 * @param {String} modifier The modifier "not" or "only" (or null).
 * @param {String} mediaType The type of media (i.e., "print").
 * @param {Array} parts Array of selectors parts making up this selector.
 * @param {int} line The line of text on which the unit resides.
 * @param {int} col The column of text on which the unit resides.
 */
function MediaQuery(modifier, mediaType, features, line, col){

    SyntaxUnit.call(this, (modifier ? modifier + " ": "") + (mediaType ? mediaType : "") + (mediaType && features.length > 0 ? " and " : "") + features.join(" and "), line, col, Parser.MEDIA_QUERY_TYPE);

    /**
     * The media modifier ("not" or "only")
     * @type String
     * @property modifier
     */
    this.modifier = modifier;

    /**
     * The mediaType (i.e., "print")
     * @type String
     * @property mediaType
     */
    this.mediaType = mediaType;

    /**
     * The parts that make up the selector.
     * @type Array
     * @property features
     */
    this.features = features;

}

MediaQuery.prototype = new SyntaxUnit();
MediaQuery.prototype.constructor = MediaQuery;

/*global Tokens, TokenStream, SyntaxError, Properties, Validation, ValidationError, SyntaxUnit,
    PropertyValue, PropertyValuePart, SelectorPart, SelectorSubPart, Selector,
    PropertyName, Combinator, MediaFeature, MediaQuery, EventTarget */

/**
 * A CSS3 parser.
 * @namespace parserlib.css
 * @class Parser
 * @constructor
 * @param {Object} options (Optional) Various options for the parser:
 *      starHack (true|false) to allow IE6 star hack as valid,
 *      underscoreHack (true|false) to interpret leading underscores
 *      as IE6-7 targeting for known properties, ieFilters (true|false)
 *      to indicate that IE < 8 filters should be accepted and not throw
 *      syntax errors.
 */
function Parser(options){

    //inherit event functionality
    EventTarget.call(this);


    this.options = options || {};

    this._tokenStream = null;
}

//Static constants
Parser.DEFAULT_TYPE = 0;
Parser.COMBINATOR_TYPE = 1;
Parser.MEDIA_FEATURE_TYPE = 2;
Parser.MEDIA_QUERY_TYPE = 3;
Parser.PROPERTY_NAME_TYPE = 4;
Parser.PROPERTY_VALUE_TYPE = 5;
Parser.PROPERTY_VALUE_PART_TYPE = 6;
Parser.SELECTOR_TYPE = 7;
Parser.SELECTOR_PART_TYPE = 8;
Parser.SELECTOR_SUB_PART_TYPE = 9;

Parser.prototype = function(){

    var proto = new EventTarget(),  //new prototype
        prop,
        additions =  {

            //restore constructor
            constructor: Parser,

            //instance constants - yuck
            DEFAULT_TYPE : 0,
            COMBINATOR_TYPE : 1,
            MEDIA_FEATURE_TYPE : 2,
            MEDIA_QUERY_TYPE : 3,
            PROPERTY_NAME_TYPE : 4,
            PROPERTY_VALUE_TYPE : 5,
            PROPERTY_VALUE_PART_TYPE : 6,
            SELECTOR_TYPE : 7,
            SELECTOR_PART_TYPE : 8,
            SELECTOR_SUB_PART_TYPE : 9,

            //-----------------------------------------------------------------
            // Grammar
            //-----------------------------------------------------------------

            _stylesheet: function(){

                /*
                 * stylesheet
                 *  : [ CHARSET_SYM S* STRING S* ';' ]?
                 *    [S|CDO|CDC]* [ import [S|CDO|CDC]* ]*
                 *    [ namespace [S|CDO|CDC]* ]*
                 *    [ [ ruleset | media | page | font_face | keyframes ] [S|CDO|CDC]* ]*
                 *  ;
                 */

                var tokenStream = this._tokenStream,
                    charset     = null,
                    count,
                    token,
                    tt;

                this.fire("startstylesheet");

                //try to read character set
                this._charset();

                this._skipCruft();

                //try to read imports - may be more than one
                while (tokenStream.peek() == Tokens.IMPORT_SYM){
                    this._import();
                    this._skipCruft();
                }

                //try to read namespaces - may be more than one
                while (tokenStream.peek() == Tokens.NAMESPACE_SYM){
                    this._namespace();
                    this._skipCruft();
                }

                //get the next token
                tt = tokenStream.peek();

                //try to read the rest
                while(tt > Tokens.EOF){

                    try {

                        switch(tt){
                            case Tokens.MEDIA_SYM:
                                this._media();
                                this._skipCruft();
                                break;
                            case Tokens.PAGE_SYM:
                                this._page();
                                this._skipCruft();
                                break;
                            case Tokens.FONT_FACE_SYM:
                                this._font_face();
                                this._skipCruft();
                                break;
                            case Tokens.KEYFRAMES_SYM:
                                this._keyframes();
                                this._skipCruft();
                                break;
                            case Tokens.VIEWPORT_SYM:
                                this._viewport();
                                this._skipCruft();
                                break;
                            case Tokens.UNKNOWN_SYM:  //unknown @ rule
                                tokenStream.get();
                                if (!this.options.strict){

                                    //fire error event
                                    this.fire({
                                        type:       "error",
                                        error:      null,
                                        message:    "Unknown @ rule: " + tokenStream.LT(0).value + ".",
                                        line:       tokenStream.LT(0).startLine,
                                        col:        tokenStream.LT(0).startCol
                                    });

                                    //skip braces
                                    count=0;
                                    while (tokenStream.advance([Tokens.LBRACE, Tokens.RBRACE]) == Tokens.LBRACE){
                                        count++;    //keep track of nesting depth
                                    }

                                    while(count){
                                        tokenStream.advance([Tokens.RBRACE]);
                                        count--;
                                    }

                                } else {
                                    //not a syntax error, rethrow it
                                    throw new SyntaxError("Unknown @ rule.", tokenStream.LT(0).startLine, tokenStream.LT(0).startCol);
                                }
                                break;
                            case Tokens.S:
                                this._readWhitespace();
                                break;
                            default:
                                if(!this._ruleset()){

                                    //error handling for known issues
                                    switch(tt){
                                        case Tokens.CHARSET_SYM:
                                            token = tokenStream.LT(1);
                                            this._charset(false);
                                            throw new SyntaxError("@charset not allowed here.", token.startLine, token.startCol);
                                        case Tokens.IMPORT_SYM:
                                            token = tokenStream.LT(1);
                                            this._import(false);
                                            throw new SyntaxError("@import not allowed here.", token.startLine, token.startCol);
                                        case Tokens.NAMESPACE_SYM:
                                            token = tokenStream.LT(1);
                                            this._namespace(false);
                                            throw new SyntaxError("@namespace not allowed here.", token.startLine, token.startCol);
                                        default:
                                            tokenStream.get();  //get the last token
                                            this._unexpectedToken(tokenStream.token());
                                    }

                                }
                        }
                    } catch(ex) {
                        if (ex instanceof SyntaxError && !this.options.strict){
                            this.fire({
                                type:       "error",
                                error:      ex,
                                message:    ex.message,
                                line:       ex.line,
                                col:        ex.col
                            });
                        } else {
                            throw ex;
                        }
                    }

                    tt = tokenStream.peek();
                }

                if (tt != Tokens.EOF){
                    this._unexpectedToken(tokenStream.token());
                }

                this.fire("endstylesheet");
            },

            _charset: function(emit){
                var tokenStream = this._tokenStream,
                    charset,
                    token,
                    line,
                    col;

                if (tokenStream.match(Tokens.CHARSET_SYM)){
                    line = tokenStream.token().startLine;
                    col = tokenStream.token().startCol;

                    this._readWhitespace();
                    tokenStream.mustMatch(Tokens.STRING);

                    token = tokenStream.token();
                    charset = token.value;

                    this._readWhitespace();
                    tokenStream.mustMatch(Tokens.SEMICOLON);

                    if (emit !== false){
                        this.fire({
                            type:   "charset",
                            charset:charset,
                            line:   line,
                            col:    col
                        });
                    }
                }
            },

            _import: function(emit){
                /*
                 * import
                 *   : IMPORT_SYM S*
                 *    [STRING|URI] S* media_query_list? ';' S*
                 */

                var tokenStream = this._tokenStream,
                    tt,
                    uri,
                    importToken,
                    mediaList   = [];

                //read import symbol
                tokenStream.mustMatch(Tokens.IMPORT_SYM);
                importToken = tokenStream.token();
                this._readWhitespace();

                tokenStream.mustMatch([Tokens.STRING, Tokens.URI]);

                //grab the URI value
                uri = tokenStream.token().value.replace(/^(?:url\()?["']?([^"']+?)["']?\)?$/, "$1");

                this._readWhitespace();

                mediaList = this._media_query_list();

                //must end with a semicolon
                tokenStream.mustMatch(Tokens.SEMICOLON);
                this._readWhitespace();

                if (emit !== false){
                    this.fire({
                        type:   "import",
                        uri:    uri,
                        media:  mediaList,
                        line:   importToken.startLine,
                        col:    importToken.startCol
                    });
                }

            },

            _namespace: function(emit){
                /*
                 * namespace
                 *   : NAMESPACE_SYM S* [namespace_prefix S*]? [STRING|URI] S* ';' S*
                 */

                var tokenStream = this._tokenStream,
                    line,
                    col,
                    prefix,
                    uri;

                //read import symbol
                tokenStream.mustMatch(Tokens.NAMESPACE_SYM);
                line = tokenStream.token().startLine;
                col = tokenStream.token().startCol;
                this._readWhitespace();

                //it's a namespace prefix - no _namespace_prefix() method because it's just an IDENT
                if (tokenStream.match(Tokens.IDENT)){
                    prefix = tokenStream.token().value;
                    this._readWhitespace();
                }

                tokenStream.mustMatch([Tokens.STRING, Tokens.URI]);
                /*if (!tokenStream.match(Tokens.STRING)){
                    tokenStream.mustMatch(Tokens.URI);
                }*/

                //grab the URI value
                uri = tokenStream.token().value.replace(/(?:url\()?["']([^"']+)["']\)?/, "$1");

                this._readWhitespace();

                //must end with a semicolon
                tokenStream.mustMatch(Tokens.SEMICOLON);
                this._readWhitespace();

                if (emit !== false){
                    this.fire({
                        type:   "namespace",
                        prefix: prefix,
                        uri:    uri,
                        line:   line,
                        col:    col
                    });
                }

            },

            _media: function(){
                /*
                 * media
                 *   : MEDIA_SYM S* media_query_list S* '{' S* ruleset* '}' S*
                 *   ;
                 */
                var tokenStream     = this._tokenStream,
                    line,
                    col,
                    mediaList;//       = [];

                //look for @media
                tokenStream.mustMatch(Tokens.MEDIA_SYM);
                line = tokenStream.token().startLine;
                col = tokenStream.token().startCol;

                this._readWhitespace();

                mediaList = this._media_query_list();

                tokenStream.mustMatch(Tokens.LBRACE);
                this._readWhitespace();

                this.fire({
                    type:   "startmedia",
                    media:  mediaList,
                    line:   line,
                    col:    col
                });

                while(true) {
                    if (tokenStream.peek() == Tokens.PAGE_SYM){
                        this._page();
                    } else if (tokenStream.peek() == Tokens.FONT_FACE_SYM){
                        this._font_face();
                    } else if (tokenStream.peek() == Tokens.VIEWPORT_SYM){
                        this._viewport();
                    } else if (!this._ruleset()){
                        break;
                    }
                }

                tokenStream.mustMatch(Tokens.RBRACE);
                this._readWhitespace();

                this.fire({
                    type:   "endmedia",
                    media:  mediaList,
                    line:   line,
                    col:    col
                });
            },


            //CSS3 Media Queries
            _media_query_list: function(){
                /*
                 * media_query_list
                 *   : S* [media_query [ ',' S* media_query ]* ]?
                 *   ;
                 */
                var tokenStream = this._tokenStream,
                    mediaList   = [];


                this._readWhitespace();

                if (tokenStream.peek() == Tokens.IDENT || tokenStream.peek() == Tokens.LPAREN){
                    mediaList.push(this._media_query());
                }

                while(tokenStream.match(Tokens.COMMA)){
                    this._readWhitespace();
                    mediaList.push(this._media_query());
                }

                return mediaList;
            },

            /*
             * Note: "expression" in the grammar maps to the _media_expression
             * method.

             */
            _media_query: function(){
                /*
                 * media_query
                 *   : [ONLY | NOT]? S* media_type S* [ AND S* expression ]*
                 *   | expression [ AND S* expression ]*
                 *   ;
                 */
                var tokenStream = this._tokenStream,
                    type        = null,
                    ident       = null,
                    token       = null,
                    expressions = [];

                if (tokenStream.match(Tokens.IDENT)){
                    ident = tokenStream.token().value.toLowerCase();

                    //since there's no custom tokens for these, need to manually check
                    if (ident != "only" && ident != "not"){
                        tokenStream.unget();
                        ident = null;
                    } else {
                        token = tokenStream.token();
                    }
                }

                this._readWhitespace();

                if (tokenStream.peek() == Tokens.IDENT){
                    type = this._media_type();
                    if (token === null){
                        token = tokenStream.token();
                    }
                } else if (tokenStream.peek() == Tokens.LPAREN){
                    if (token === null){
                        token = tokenStream.LT(1);
                    }
                    expressions.push(this._media_expression());
                }

                if (type === null && expressions.length === 0){
                    return null;
                } else {
                    this._readWhitespace();
                    while (tokenStream.match(Tokens.IDENT)){
                        if (tokenStream.token().value.toLowerCase() != "and"){
                            this._unexpectedToken(tokenStream.token());
                        }

                        this._readWhitespace();
                        expressions.push(this._media_expression());
                    }
                }

                return new MediaQuery(ident, type, expressions, token.startLine, token.startCol);
            },

            //CSS3 Media Queries
            _media_type: function(){
                /*
                 * media_type
                 *   : IDENT
                 *   ;
                 */
                return this._media_feature();
            },

            /**
             * Note: in CSS3 Media Queries, this is called "expression".
             * Renamed here to avoid conflict with CSS3 Selectors
             * definition of "expression". Also note that "expr" in the
             * grammar now maps to "expression" from CSS3 selectors.
             * @method _media_expression
             * @private
             */
            _media_expression: function(){
                /*
                 * expression
                 *  : '(' S* media_feature S* [ ':' S* expr ]? ')' S*
                 *  ;
                 */
                var tokenStream = this._tokenStream,
                    feature     = null,
                    token,
                    expression  = null;

                tokenStream.mustMatch(Tokens.LPAREN);

                feature = this._media_feature();
                this._readWhitespace();

                if (tokenStream.match(Tokens.COLON)){
                    this._readWhitespace();
                    token = tokenStream.LT(1);
                    expression = this._expression();
                }

                tokenStream.mustMatch(Tokens.RPAREN);
                this._readWhitespace();

                return new MediaFeature(feature, (expression ? new SyntaxUnit(expression, token.startLine, token.startCol) : null));
            },

            //CSS3 Media Queries
            _media_feature: function(){
                /*
                 * media_feature
                 *   : IDENT
                 *   ;
                 */
                var tokenStream = this._tokenStream;

                tokenStream.mustMatch(Tokens.IDENT);

                return SyntaxUnit.fromToken(tokenStream.token());
            },

            //CSS3 Paged Media
            _page: function(){
                /*
                 * page:
                 *    PAGE_SYM S* IDENT? pseudo_page? S*
                 *    '{' S* [ declaration | margin ]? [ ';' S* [ declaration | margin ]? ]* '}' S*
                 *    ;
                 */
                var tokenStream = this._tokenStream,
                    line,
                    col,
                    identifier  = null,
                    pseudoPage  = null;

                //look for @page
                tokenStream.mustMatch(Tokens.PAGE_SYM);
                line = tokenStream.token().startLine;
                col = tokenStream.token().startCol;

                this._readWhitespace();

                if (tokenStream.match(Tokens.IDENT)){
                    identifier = tokenStream.token().value;

                    //The value 'auto' may not be used as a page name and MUST be treated as a syntax error.
                    if (identifier.toLowerCase() === "auto"){
                        this._unexpectedToken(tokenStream.token());
                    }
                }

                //see if there's a colon upcoming
                if (tokenStream.peek() == Tokens.COLON){
                    pseudoPage = this._pseudo_page();
                }

                this._readWhitespace();

                this.fire({
                    type:   "startpage",
                    id:     identifier,
                    pseudo: pseudoPage,
                    line:   line,
                    col:    col
                });

                this._readDeclarations(true, true);

                this.fire({
                    type:   "endpage",
                    id:     identifier,
                    pseudo: pseudoPage,
                    line:   line,
                    col:    col
                });

            },

            //CSS3 Paged Media
            _margin: function(){
                /*
                 * margin :
                 *    margin_sym S* '{' declaration [ ';' S* declaration? ]* '}' S*
                 *    ;
                 */
                var tokenStream = this._tokenStream,
                    line,
                    col,
                    marginSym   = this._margin_sym();

                if (marginSym){
                    line = tokenStream.token().startLine;
                    col = tokenStream.token().startCol;

                    this.fire({
                        type: "startpagemargin",
                        margin: marginSym,
                        line:   line,
                        col:    col
                    });

                    this._readDeclarations(true);

                    this.fire({
                        type: "endpagemargin",
                        margin: marginSym,
                        line:   line,
                        col:    col
                    });
                    return true;
                } else {
                    return false;
                }
            },

            //CSS3 Paged Media
            _margin_sym: function(){

                /*
                 * margin_sym :
                 *    TOPLEFTCORNER_SYM |
                 *    TOPLEFT_SYM |
                 *    TOPCENTER_SYM |
                 *    TOPRIGHT_SYM |
                 *    TOPRIGHTCORNER_SYM |
                 *    BOTTOMLEFTCORNER_SYM |
                 *    BOTTOMLEFT_SYM |
                 *    BOTTOMCENTER_SYM |
                 *    BOTTOMRIGHT_SYM |
                 *    BOTTOMRIGHTCORNER_SYM |
                 *    LEFTTOP_SYM |
                 *    LEFTMIDDLE_SYM |
                 *    LEFTBOTTOM_SYM |
                 *    RIGHTTOP_SYM |
                 *    RIGHTMIDDLE_SYM |
                 *    RIGHTBOTTOM_SYM
                 *    ;
                 */

                var tokenStream = this._tokenStream;

                if(tokenStream.match([Tokens.TOPLEFTCORNER_SYM, Tokens.TOPLEFT_SYM,
                        Tokens.TOPCENTER_SYM, Tokens.TOPRIGHT_SYM, Tokens.TOPRIGHTCORNER_SYM,
                        Tokens.BOTTOMLEFTCORNER_SYM, Tokens.BOTTOMLEFT_SYM,
                        Tokens.BOTTOMCENTER_SYM, Tokens.BOTTOMRIGHT_SYM,
                        Tokens.BOTTOMRIGHTCORNER_SYM, Tokens.LEFTTOP_SYM,
                        Tokens.LEFTMIDDLE_SYM, Tokens.LEFTBOTTOM_SYM, Tokens.RIGHTTOP_SYM,
                        Tokens.RIGHTMIDDLE_SYM, Tokens.RIGHTBOTTOM_SYM]))
                {
                    return SyntaxUnit.fromToken(tokenStream.token());
                } else {
                    return null;
                }

            },

            _pseudo_page: function(){
                /*
                 * pseudo_page
                 *   : ':' IDENT
                 *   ;
                 */

                var tokenStream = this._tokenStream;

                tokenStream.mustMatch(Tokens.COLON);
                tokenStream.mustMatch(Tokens.IDENT);

                //TODO: CSS3 Paged Media says only "left", "center", and "right" are allowed

                return tokenStream.token().value;
            },

            _font_face: function(){
                /*
                 * font_face
                 *   : FONT_FACE_SYM S*
                 *     '{' S* declaration [ ';' S* declaration ]* '}' S*
                 *   ;
                 */
                var tokenStream = this._tokenStream,
                    line,
                    col;

                //look for @page
                tokenStream.mustMatch(Tokens.FONT_FACE_SYM);
                line = tokenStream.token().startLine;
                col = tokenStream.token().startCol;

                this._readWhitespace();

                this.fire({
                    type:   "startfontface",
                    line:   line,
                    col:    col
                });

                this._readDeclarations(true);

                this.fire({
                    type:   "endfontface",
                    line:   line,
                    col:    col
                });
            },

            _viewport: function(){
                /*
                 * viewport
                 *   : VIEWPORT_SYM S*
                 *     '{' S* declaration? [ ';' S* declaration? ]* '}' S*
                 *   ;
                 */
                 var tokenStream = this._tokenStream,
                    line,
                    col;

                    tokenStream.mustMatch(Tokens.VIEWPORT_SYM);
                    line = tokenStream.token().startLine;
                    col = tokenStream.token().startCol;

                    this._readWhitespace();

                    this.fire({
                        type:   "startviewport",
                        line:   line,
                        col:    col
                    });

                    this._readDeclarations(true);

                    this.fire({
                        type:   "endviewport",
                        line:   line,
                        col:    col
                    });

            },

            _operator: function(inFunction){

                /*
                 * operator (outside function)
                 *  : '/' S* | ',' S* | /( empty )/
                 * operator (inside function)
                 *  : '/' S* | '+' S* | '*' S* | '-' S* /( empty )/
                 *  ;
                 */

                var tokenStream = this._tokenStream,
                    token       = null;

                if (tokenStream.match([Tokens.SLASH, Tokens.COMMA]) ||
                    (inFunction && tokenStream.match([Tokens.PLUS, Tokens.STAR, Tokens.MINUS]))){
                    token =  tokenStream.token();
                    this._readWhitespace();
                }
                return token ? PropertyValuePart.fromToken(token) : null;

            },

            _combinator: function(){

                /*
                 * combinator
                 *  : PLUS S* | GREATER S* | TILDE S* | S+
                 *  ;
                 */

                var tokenStream = this._tokenStream,
                    value       = null,
                    token;

                if(tokenStream.match([Tokens.PLUS, Tokens.GREATER, Tokens.TILDE])){
                    token = tokenStream.token();
                    value = new Combinator(token.value, token.startLine, token.startCol);
                    this._readWhitespace();
                }

                return value;
            },

            _unary_operator: function(){

                /*
                 * unary_operator
                 *  : '-' | '+'
                 *  ;
                 */

                var tokenStream = this._tokenStream;

                if (tokenStream.match([Tokens.MINUS, Tokens.PLUS])){
                    return tokenStream.token().value;
                } else {
                    return null;
                }
            },

            _property: function(){

                /*
                 * property
                 *   : IDENT S*
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    value       = null,
                    hack        = null,
                    tokenValue,
                    token,
                    line,
                    col;

                //check for star hack - throws error if not allowed
                if (tokenStream.peek() == Tokens.STAR && this.options.starHack){
                    tokenStream.get();
                    token = tokenStream.token();
                    hack = token.value;
                    line = token.startLine;
                    col = token.startCol;
                }

                if(tokenStream.match(Tokens.IDENT)){
                    token = tokenStream.token();
                    tokenValue = token.value;

                    //check for underscore hack - no error if not allowed because it's valid CSS syntax
                    if (tokenValue.charAt(0) == "_" && this.options.underscoreHack){
                        hack = "_";
                        tokenValue = tokenValue.substring(1);
                    }

                    value = new PropertyName(tokenValue, hack, (line||token.startLine), (col||token.startCol));
                    this._readWhitespace();
                }

                return value;
            },

            //Augmented with CSS3 Selectors
            _ruleset: function(){
                /*
                 * ruleset
                 *   : selectors_group
                 *     '{' S* declaration? [ ';' S* declaration? ]* '}' S*
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    tt,
                    selectors;


                /*
                 * Error Recovery: If even a single selector fails to parse,
                 * then the entire ruleset should be thrown away.
                 */
                try {
                    selectors = this._selectors_group();
                } catch (ex){
                    if (ex instanceof SyntaxError && !this.options.strict){

                        //fire error event
                        this.fire({
                            type:       "error",
                            error:      ex,
                            message:    ex.message,
                            line:       ex.line,
                            col:        ex.col
                        });

                        //skip over everything until closing brace
                        tt = tokenStream.advance([Tokens.RBRACE]);
                        if (tt == Tokens.RBRACE){
                            //if there's a right brace, the rule is finished so don't do anything
                        } else {
                            //otherwise, rethrow the error because it wasn't handled properly
                            throw ex;
                        }

                    } else {
                        //not a syntax error, rethrow it
                        throw ex;
                    }

                    //trigger parser to continue
                    return true;
                }

                //if it got here, all selectors parsed
                if (selectors){

                    this.fire({
                        type:       "startrule",
                        selectors:  selectors,
                        line:       selectors[0].line,
                        col:        selectors[0].col
                    });

                    this._readDeclarations(true);

                    this.fire({
                        type:       "endrule",
                        selectors:  selectors,
                        line:       selectors[0].line,
                        col:        selectors[0].col
                    });

                }

                return selectors;

            },

            //CSS3 Selectors
            _selectors_group: function(){

                /*
                 * selectors_group
                 *   : selector [ COMMA S* selector ]*
                 *   ;
                 */
                var tokenStream = this._tokenStream,
                    selectors   = [],
                    selector;

                selector = this._selector();
                if (selector !== null){

                    selectors.push(selector);
                    while(tokenStream.match(Tokens.COMMA)){
                        this._readWhitespace();
                        selector = this._selector();
                        if (selector !== null){
                            selectors.push(selector);
                        } else {
                            this._unexpectedToken(tokenStream.LT(1));
                        }
                    }
                }

                return selectors.length ? selectors : null;
            },

            //CSS3 Selectors
            _selector: function(){
                /*
                 * selector
                 *   : simple_selector_sequence [ combinator simple_selector_sequence ]*
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    selector    = [],
                    nextSelector = null,
                    combinator  = null,
                    ws          = null;

                //if there's no simple selector, then there's no selector
                nextSelector = this._simple_selector_sequence();
                if (nextSelector === null){
                    return null;
                }

                selector.push(nextSelector);

                do {

                    //look for a combinator
                    combinator = this._combinator();

                    if (combinator !== null){
                        selector.push(combinator);
                        nextSelector = this._simple_selector_sequence();

                        //there must be a next selector
                        if (nextSelector === null){
                            this._unexpectedToken(tokenStream.LT(1));
                        } else {

                            //nextSelector is an instance of SelectorPart
                            selector.push(nextSelector);
                        }
                    } else {

                        //if there's not whitespace, we're done
                        if (this._readWhitespace()){

                            //add whitespace separator
                            ws = new Combinator(tokenStream.token().value, tokenStream.token().startLine, tokenStream.token().startCol);

                            //combinator is not required
                            combinator = this._combinator();

                            //selector is required if there's a combinator
                            nextSelector = this._simple_selector_sequence();
                            if (nextSelector === null){
                                if (combinator !== null){
                                    this._unexpectedToken(tokenStream.LT(1));
                                }
                            } else {

                                if (combinator !== null){
                                    selector.push(combinator);
                                } else {
                                    selector.push(ws);
                                }

                                selector.push(nextSelector);
                            }
                        } else {
                            break;
                        }

                    }
                } while(true);

                return new Selector(selector, selector[0].line, selector[0].col);
            },

            //CSS3 Selectors
            _simple_selector_sequence: function(){
                /*
                 * simple_selector_sequence
                 *   : [ type_selector | universal ]
                 *     [ HASH | class | attrib | pseudo | negation ]*
                 *   | [ HASH | class | attrib | pseudo | negation ]+
                 *   ;
                 */

                var tokenStream = this._tokenStream,

                    //parts of a simple selector
                    elementName = null,
                    modifiers   = [],

                    //complete selector text
                    selectorText= "",

                    //the different parts after the element name to search for
                    components  = [
                        //HASH
                        function(){
                            return tokenStream.match(Tokens.HASH) ?
                                    new SelectorSubPart(tokenStream.token().value, "id", tokenStream.token().startLine, tokenStream.token().startCol) :
                                    null;
                        },
                        this._class,
                        this._attrib,
                        this._pseudo,
                        this._negation
                    ],
                    i           = 0,
                    len         = components.length,
                    component   = null,
                    found       = false,
                    line,
                    col;


                //get starting line and column for the selector
                line = tokenStream.LT(1).startLine;
                col = tokenStream.LT(1).startCol;

                elementName = this._type_selector();
                if (!elementName){
                    elementName = this._universal();
                }

                if (elementName !== null){
                    selectorText += elementName;
                }

                while(true){

                    //whitespace means we're done
                    if (tokenStream.peek() === Tokens.S){
                        break;
                    }

                    //check for each component
                    while(i < len && component === null){
                        component = components[i++].call(this);
                    }

                    if (component === null){

                        //we don't have a selector
                        if (selectorText === ""){
                            return null;
                        } else {
                            break;
                        }
                    } else {
                        i = 0;
                        modifiers.push(component);
                        selectorText += component.toString();
                        component = null;
                    }
                }


                return selectorText !== "" ?
                        new SelectorPart(elementName, modifiers, selectorText, line, col) :
                        null;
            },

            //CSS3 Selectors
            _type_selector: function(){
                /*
                 * type_selector
                 *   : [ namespace_prefix ]? element_name
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    ns          = this._namespace_prefix(),
                    elementName = this._element_name();

                if (!elementName){
                    /*
                     * Need to back out the namespace that was read due to both
                     * type_selector and universal reading namespace_prefix
                     * first. Kind of hacky, but only way I can figure out
                     * right now how to not change the grammar.
                     */
                    if (ns){
                        tokenStream.unget();
                        if (ns.length > 1){
                            tokenStream.unget();
                        }
                    }

                    return null;
                } else {
                    if (ns){
                        elementName.text = ns + elementName.text;
                        elementName.col -= ns.length;
                    }
                    return elementName;
                }
            },

            //CSS3 Selectors
            _class: function(){
                /*
                 * class
                 *   : '.' IDENT
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    token;

                if (tokenStream.match(Tokens.DOT)){
                    tokenStream.mustMatch(Tokens.IDENT);
                    token = tokenStream.token();
                    return new SelectorSubPart("." + token.value, "class", token.startLine, token.startCol - 1);
                } else {
                    return null;
                }

            },

            //CSS3 Selectors
            _element_name: function(){
                /*
                 * element_name
                 *   : IDENT
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    token;

                if (tokenStream.match(Tokens.IDENT)){
                    token = tokenStream.token();
                    return new SelectorSubPart(token.value, "elementName", token.startLine, token.startCol);

                } else {
                    return null;
                }
            },

            //CSS3 Selectors
            _namespace_prefix: function(){
                /*
                 * namespace_prefix
                 *   : [ IDENT | '*' ]? '|'
                 *   ;
                 */
                var tokenStream = this._tokenStream,
                    value       = "";

                //verify that this is a namespace prefix
                if (tokenStream.LA(1) === Tokens.PIPE || tokenStream.LA(2) === Tokens.PIPE){

                    if(tokenStream.match([Tokens.IDENT, Tokens.STAR])){
                        value += tokenStream.token().value;
                    }

                    tokenStream.mustMatch(Tokens.PIPE);
                    value += "|";

                }

                return value.length ? value : null;
            },

            //CSS3 Selectors
            _universal: function(){
                /*
                 * universal
                 *   : [ namespace_prefix ]? '*'
                 *   ;
                 */
                var tokenStream = this._tokenStream,
                    value       = "",
                    ns;

                ns = this._namespace_prefix();
                if(ns){
                    value += ns;
                }

                if(tokenStream.match(Tokens.STAR)){
                    value += "*";
                }

                return value.length ? value : null;

           },

            //CSS3 Selectors
            _attrib: function(){
                /*
                 * attrib
                 *   : '[' S* [ namespace_prefix ]? IDENT S*
                 *         [ [ PREFIXMATCH |
                 *             SUFFIXMATCH |
                 *             SUBSTRINGMATCH |
                 *             '=' |
                 *             INCLUDES |
                 *             DASHMATCH ] S* [ IDENT | STRING ] S*
                 *         ]? ']'
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    value       = null,
                    ns,
                    token;

                if (tokenStream.match(Tokens.LBRACKET)){
                    token = tokenStream.token();
                    value = token.value;
                    value += this._readWhitespace();

                    ns = this._namespace_prefix();

                    if (ns){
                        value += ns;
                    }

                    tokenStream.mustMatch(Tokens.IDENT);
                    value += tokenStream.token().value;
                    value += this._readWhitespace();

                    if(tokenStream.match([Tokens.PREFIXMATCH, Tokens.SUFFIXMATCH, Tokens.SUBSTRINGMATCH,
                            Tokens.EQUALS, Tokens.INCLUDES, Tokens.DASHMATCH])){

                        value += tokenStream.token().value;
                        value += this._readWhitespace();

                        tokenStream.mustMatch([Tokens.IDENT, Tokens.STRING]);
                        value += tokenStream.token().value;
                        value += this._readWhitespace();
                    }

                    tokenStream.mustMatch(Tokens.RBRACKET);

                    return new SelectorSubPart(value + "]", "attribute", token.startLine, token.startCol);
                } else {
                    return null;
                }
            },

            //CSS3 Selectors
            _pseudo: function(){

                /*
                 * pseudo
                 *   : ':' ':'? [ IDENT | functional_pseudo ]
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    pseudo      = null,
                    colons      = ":",
                    line,
                    col;

                if (tokenStream.match(Tokens.COLON)){

                    if (tokenStream.match(Tokens.COLON)){
                        colons += ":";
                    }

                    if (tokenStream.match(Tokens.IDENT)){
                        pseudo = tokenStream.token().value;
                        line = tokenStream.token().startLine;
                        col = tokenStream.token().startCol - colons.length;
                    } else if (tokenStream.peek() == Tokens.FUNCTION){
                        line = tokenStream.LT(1).startLine;
                        col = tokenStream.LT(1).startCol - colons.length;
                        pseudo = this._functional_pseudo();
                    }

                    if (pseudo){
                        pseudo = new SelectorSubPart(colons + pseudo, "pseudo", line, col);
                    }
                }

                return pseudo;
            },

            //CSS3 Selectors
            _functional_pseudo: function(){
                /*
                 * functional_pseudo
                 *   : FUNCTION S* expression ')'
                 *   ;
                */

                var tokenStream = this._tokenStream,
                    value = null;

                if(tokenStream.match(Tokens.FUNCTION)){
                    value = tokenStream.token().value;
                    value += this._readWhitespace();
                    value += this._expression();
                    tokenStream.mustMatch(Tokens.RPAREN);
                    value += ")";
                }

                return value;
            },

            //CSS3 Selectors
            _expression: function(){
                /*
                 * expression
                 *   : [ [ PLUS | '-' | DIMENSION | NUMBER | STRING | IDENT ] S* ]+
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    value       = "";

                while(tokenStream.match([Tokens.PLUS, Tokens.MINUS, Tokens.DIMENSION,
                        Tokens.NUMBER, Tokens.STRING, Tokens.IDENT, Tokens.LENGTH,
                        Tokens.FREQ, Tokens.ANGLE, Tokens.TIME,
                        Tokens.RESOLUTION, Tokens.SLASH])){

                    value += tokenStream.token().value;
                    value += this._readWhitespace();
                }

                return value.length ? value : null;

            },

            //CSS3 Selectors
            _negation: function(){
                /*
                 * negation
                 *   : NOT S* negation_arg S* ')'
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    line,
                    col,
                    value       = "",
                    arg,
                    subpart     = null;

                if (tokenStream.match(Tokens.NOT)){
                    value = tokenStream.token().value;
                    line = tokenStream.token().startLine;
                    col = tokenStream.token().startCol;
                    value += this._readWhitespace();
                    arg = this._negation_arg();
                    value += arg;
                    value += this._readWhitespace();
                    tokenStream.match(Tokens.RPAREN);
                    value += tokenStream.token().value;

                    subpart = new SelectorSubPart(value, "not", line, col);
                    subpart.args.push(arg);
                }

                return subpart;
            },

            //CSS3 Selectors
            _negation_arg: function(){
                /*
                 * negation_arg
                 *   : type_selector | universal | HASH | class | attrib | pseudo
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    args        = [
                        this._type_selector,
                        this._universal,
                        function(){
                            return tokenStream.match(Tokens.HASH) ?
                                    new SelectorSubPart(tokenStream.token().value, "id", tokenStream.token().startLine, tokenStream.token().startCol) :
                                    null;
                        },
                        this._class,
                        this._attrib,
                        this._pseudo
                    ],
                    arg         = null,
                    i           = 0,
                    len         = args.length,
                    elementName,
                    line,
                    col,
                    part;

                line = tokenStream.LT(1).startLine;
                col = tokenStream.LT(1).startCol;

                while(i < len && arg === null){

                    arg = args[i].call(this);
                    i++;
                }

                //must be a negation arg
                if (arg === null){
                    this._unexpectedToken(tokenStream.LT(1));
                }

                //it's an element name
                if (arg.type == "elementName"){
                    part = new SelectorPart(arg, [], arg.toString(), line, col);
                } else {
                    part = new SelectorPart(null, [arg], arg.toString(), line, col);
                }

                return part;
            },

            _declaration: function(){

                /*
                 * declaration
                 *   : property ':' S* expr prio?
                 *   | /( empty )/
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    property    = null,
                    expr        = null,
                    prio        = null,
                    error       = null,
                    invalid     = null,
                    propertyName= "";

                property = this._property();
                if (property !== null){

                    tokenStream.mustMatch(Tokens.COLON);
                    this._readWhitespace();

                    expr = this._expr();

                    //if there's no parts for the value, it's an error
                    if (!expr || expr.length === 0){
                        this._unexpectedToken(tokenStream.LT(1));
                    }

                    prio = this._prio();

                    /*
                     * If hacks should be allowed, then only check the root
                     * property. If hacks should not be allowed, treat
                     * _property or *property as invalid properties.
                     */
                    propertyName = property.toString();
                    if (this.options.starHack && property.hack == "*" ||
                            this.options.underscoreHack && property.hack == "_") {

                        propertyName = property.text;
                    }

                    try {
                        this._validateProperty(propertyName, expr);
                    } catch (ex) {
                        invalid = ex;
                    }

                    this.fire({
                        type:       "property",
                        property:   property,
                        value:      expr,
                        important:  prio,
                        line:       property.line,
                        col:        property.col,
                        invalid:    invalid
                    });

                    return true;
                } else {
                    return false;
                }
            },

            _prio: function(){
                /*
                 * prio
                 *   : IMPORTANT_SYM S*
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    result      = tokenStream.match(Tokens.IMPORTANT_SYM);

                this._readWhitespace();
                return result;
            },

            _expr: function(inFunction){
                /*
                 * expr
                 *   : term [ operator term ]*
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    values      = [],
					//valueParts	= [],
                    value       = null,
                    operator    = null;

                value = this._term(inFunction);
                if (value !== null){

                    values.push(value);

                    do {
                        operator = this._operator(inFunction);

                        //if there's an operator, keep building up the value parts
                        if (operator){
                            values.push(operator);
                        } /*else {
                            //if there's not an operator, you have a full value
							values.push(new PropertyValue(valueParts, valueParts[0].line, valueParts[0].col));
							valueParts = [];
						}*/

                        value = this._term(inFunction);

                        if (value === null){
                            break;
                        } else {
                            values.push(value);
                        }
                    } while(true);
                }

				//cleanup
                /*if (valueParts.length){
                    values.push(new PropertyValue(valueParts, valueParts[0].line, valueParts[0].col));
                }*/

                return values.length > 0 ? new PropertyValue(values, values[0].line, values[0].col) : null;
            },

            _term: function(inFunction){

                /*
                 * term
                 *   : unary_operator?
                 *     [ NUMBER S* | PERCENTAGE S* | LENGTH S* | ANGLE S* |
                 *       TIME S* | FREQ S* | function | ie_function ]
                 *   | STRING S* | IDENT S* | URI S* | UNICODERANGE S* | hexcolor
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    unary       = null,
                    value       = null,
                    endChar     = null,
                    token,
                    line,
                    col;

                //returns the operator or null
                unary = this._unary_operator();
                if (unary !== null){
                    line = tokenStream.token().startLine;
                    col = tokenStream.token().startCol;
                }

                //exception for IE filters
                if (tokenStream.peek() == Tokens.IE_FUNCTION && this.options.ieFilters){

                    value = this._ie_function();
                    if (unary === null){
                        line = tokenStream.token().startLine;
                        col = tokenStream.token().startCol;
                    }

                //see if it's a simple block
                } else if (inFunction && tokenStream.match([Tokens.LPAREN, Tokens.LBRACE, Tokens.LBRACKET])){

                    token = tokenStream.token();
                    endChar = token.endChar;
                    value = token.value + this._expr(inFunction).text;
                    if (unary === null){
                        line = tokenStream.token().startLine;
                        col = tokenStream.token().startCol;
                    }
                    tokenStream.mustMatch(Tokens.type(endChar));
                    value += endChar;
                    this._readWhitespace();

                //see if there's a simple match
                } else if (tokenStream.match([Tokens.NUMBER, Tokens.PERCENTAGE, Tokens.LENGTH,
                        Tokens.ANGLE, Tokens.TIME,
                        Tokens.FREQ, Tokens.STRING, Tokens.IDENT, Tokens.URI, Tokens.UNICODE_RANGE])){

                    value = tokenStream.token().value;
                    if (unary === null){
                        line = tokenStream.token().startLine;
                        col = tokenStream.token().startCol;
                    }
                    this._readWhitespace();
                } else {

                    //see if it's a color
                    token = this._hexcolor();
                    if (token === null){

                        //if there's no unary, get the start of the next token for line/col info
                        if (unary === null){
                            line = tokenStream.LT(1).startLine;
                            col = tokenStream.LT(1).startCol;
                        }

                        //has to be a function
                        if (value === null){

                            /*
                             * This checks for alpha(opacity=0) style of IE
                             * functions. IE_FUNCTION only presents progid: style.
                             */
                            if (tokenStream.LA(3) == Tokens.EQUALS && this.options.ieFilters){
                                value = this._ie_function();
                            } else {
                                value = this._function();
                            }
                        }

                        /*if (value === null){
                            return null;
                            //throw new Error("Expected identifier at line " + tokenStream.token().startLine + ", character " +  tokenStream.token().startCol + ".");
                        }*/

                    } else {
                        value = token.value;
                        if (unary === null){
                            line = token.startLine;
                            col = token.startCol;
                        }
                    }

                }

                return value !== null ?
                        new PropertyValuePart(unary !== null ? unary + value : value, line, col) :
                        null;

            },

            _function: function(){

                /*
                 * function
                 *   : FUNCTION S* expr ')' S*
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    functionText = null,
                    expr        = null,
                    lt;

                if (tokenStream.match(Tokens.FUNCTION)){
                    functionText = tokenStream.token().value;
                    this._readWhitespace();
                    expr = this._expr(true);
                    functionText += expr;

                    //START: Horrible hack in case it's an IE filter
                    if (this.options.ieFilters && tokenStream.peek() == Tokens.EQUALS){
                        do {

                            if (this._readWhitespace()){
                                functionText += tokenStream.token().value;
                            }

                            //might be second time in the loop
                            if (tokenStream.LA(0) == Tokens.COMMA){
                                functionText += tokenStream.token().value;
                            }

                            tokenStream.match(Tokens.IDENT);
                            functionText += tokenStream.token().value;

                            tokenStream.match(Tokens.EQUALS);
                            functionText += tokenStream.token().value;

                            //functionText += this._term();
                            lt = tokenStream.peek();
                            while(lt != Tokens.COMMA && lt != Tokens.S && lt != Tokens.RPAREN){
                                tokenStream.get();
                                functionText += tokenStream.token().value;
                                lt = tokenStream.peek();
                            }
                        } while(tokenStream.match([Tokens.COMMA, Tokens.S]));
                    }

                    //END: Horrible Hack

                    tokenStream.match(Tokens.RPAREN);
                    functionText += ")";
                    this._readWhitespace();
                }

                return functionText;
            },

            _ie_function: function(){

                /* (My own extension)
                 * ie_function
                 *   : IE_FUNCTION S* IDENT '=' term [S* ','? IDENT '=' term]+ ')' S*
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    functionText = null,
                    expr        = null,
                    lt;

                //IE function can begin like a regular function, too
                if (tokenStream.match([Tokens.IE_FUNCTION, Tokens.FUNCTION])){
                    functionText = tokenStream.token().value;

                    do {

                        if (this._readWhitespace()){
                            functionText += tokenStream.token().value;
                        }

                        //might be second time in the loop
                        if (tokenStream.LA(0) == Tokens.COMMA){
                            functionText += tokenStream.token().value;
                        }

                        tokenStream.match(Tokens.IDENT);
                        functionText += tokenStream.token().value;

                        tokenStream.match(Tokens.EQUALS);
                        functionText += tokenStream.token().value;

                        //functionText += this._term();
                        lt = tokenStream.peek();
                        while(lt != Tokens.COMMA && lt != Tokens.S && lt != Tokens.RPAREN){
                            tokenStream.get();
                            functionText += tokenStream.token().value;
                            lt = tokenStream.peek();
                        }
                    } while(tokenStream.match([Tokens.COMMA, Tokens.S]));

                    tokenStream.match(Tokens.RPAREN);
                    functionText += ")";
                    this._readWhitespace();
                }

                return functionText;
            },

            _hexcolor: function(){
                /*
                 * There is a constraint on the color that it must
                 * have either 3 or 6 hex-digits (i.e., [0-9a-fA-F])
                 * after the "#"; e.g., "#000" is OK, but "#abcd" is not.
                 *
                 * hexcolor
                 *   : HASH S*
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    token = null,
                    color;

                if(tokenStream.match(Tokens.HASH)){

                    //need to do some validation here

                    token = tokenStream.token();
                    color = token.value;
                    if (!/#[a-f0-9]{3,6}/i.test(color)){
                        throw new SyntaxError("Expected a hex color but found '" + color + "' at line " + token.startLine + ", col " + token.startCol + ".", token.startLine, token.startCol);
                    }
                    this._readWhitespace();
                }

                return token;
            },

            //-----------------------------------------------------------------
            // Animations methods
            //-----------------------------------------------------------------

            _keyframes: function(){

                /*
                 * keyframes:
                 *   : KEYFRAMES_SYM S* keyframe_name S* '{' S* keyframe_rule* '}' {
                 *   ;
                 */
                var tokenStream = this._tokenStream,
                    token,
                    tt,
                    name,
                    prefix = "";

                tokenStream.mustMatch(Tokens.KEYFRAMES_SYM);
                token = tokenStream.token();
                if (/^@\-([^\-]+)\-/.test(token.value)) {
                    prefix = RegExp.$1;
                }

                this._readWhitespace();
                name = this._keyframe_name();

                this._readWhitespace();
                tokenStream.mustMatch(Tokens.LBRACE);

                this.fire({
                    type:   "startkeyframes",
                    name:   name,
                    prefix: prefix,
                    line:   token.startLine,
                    col:    token.startCol
                });

                this._readWhitespace();
                tt = tokenStream.peek();

                //check for key
                while(tt == Tokens.IDENT || tt == Tokens.PERCENTAGE) {
                    this._keyframe_rule();
                    this._readWhitespace();
                    tt = tokenStream.peek();
                }

                this.fire({
                    type:   "endkeyframes",
                    name:   name,
                    prefix: prefix,
                    line:   token.startLine,
                    col:    token.startCol
                });

                this._readWhitespace();
                tokenStream.mustMatch(Tokens.RBRACE);

            },

            _keyframe_name: function(){

                /*
                 * keyframe_name:
                 *   : IDENT
                 *   | STRING
                 *   ;
                 */
                var tokenStream = this._tokenStream,
                    token;

                tokenStream.mustMatch([Tokens.IDENT, Tokens.STRING]);
                return SyntaxUnit.fromToken(tokenStream.token());
            },

            _keyframe_rule: function(){

                /*
                 * keyframe_rule:
                 *   : key_list S*
                 *     '{' S* declaration [ ';' S* declaration ]* '}' S*
                 *   ;
                 */
                var tokenStream = this._tokenStream,
                    token,
                    keyList = this._key_list();

                this.fire({
                    type:   "startkeyframerule",
                    keys:   keyList,
                    line:   keyList[0].line,
                    col:    keyList[0].col
                });

                this._readDeclarations(true);

                this.fire({
                    type:   "endkeyframerule",
                    keys:   keyList,
                    line:   keyList[0].line,
                    col:    keyList[0].col
                });

            },

            _key_list: function(){

                /*
                 * key_list:
                 *   : key [ S* ',' S* key]*
                 *   ;
                 */
                var tokenStream = this._tokenStream,
                    token,
                    key,
                    keyList = [];

                //must be least one key
                keyList.push(this._key());

                this._readWhitespace();

                while(tokenStream.match(Tokens.COMMA)){
                    this._readWhitespace();
                    keyList.push(this._key());
                    this._readWhitespace();
                }

                return keyList;
            },

            _key: function(){
                /*
                 * There is a restriction that IDENT can be only "from" or "to".
                 *
                 * key
                 *   : PERCENTAGE
                 *   | IDENT
                 *   ;
                 */

                var tokenStream = this._tokenStream,
                    token;

                if (tokenStream.match(Tokens.PERCENTAGE)){
                    return SyntaxUnit.fromToken(tokenStream.token());
                } else if (tokenStream.match(Tokens.IDENT)){
                    token = tokenStream.token();

                    if (/from|to/i.test(token.value)){
                        return SyntaxUnit.fromToken(token);
                    }

                    tokenStream.unget();
                }

                //if it gets here, there wasn't a valid token, so time to explode
                this._unexpectedToken(tokenStream.LT(1));
            },

            //-----------------------------------------------------------------
            // Helper methods
            //-----------------------------------------------------------------

            /**
             * Not part of CSS grammar, but useful for skipping over
             * combination of white space and HTML-style comments.
             * @return {void}
             * @method _skipCruft
             * @private
             */
            _skipCruft: function(){
                while(this._tokenStream.match([Tokens.S, Tokens.CDO, Tokens.CDC])){
                    //noop
                }
            },

            /**
             * Not part of CSS grammar, but this pattern occurs frequently
             * in the official CSS grammar. Split out here to eliminate
             * duplicate code.
             * @param {Boolean} checkStart Indicates if the rule should check
             *      for the left brace at the beginning.
             * @param {Boolean} readMargins Indicates if the rule should check
             *      for margin patterns.
             * @return {void}
             * @method _readDeclarations
             * @private
             */
            _readDeclarations: function(checkStart, readMargins){
                /*
                 * Reads the pattern
                 * S* '{' S* declaration [ ';' S* declaration ]* '}' S*
                 * or
                 * S* '{' S* [ declaration | margin ]? [ ';' S* [ declaration | margin ]? ]* '}' S*
                 * Note that this is how it is described in CSS3 Paged Media, but is actually incorrect.
                 * A semicolon is only necessary following a declaration is there's another declaration
                 * or margin afterwards.
                 */
                var tokenStream = this._tokenStream,
                    tt;


                this._readWhitespace();

                if (checkStart){
                    tokenStream.mustMatch(Tokens.LBRACE);
                }

                this._readWhitespace();

                try {

                    while(true){

                        if (tokenStream.match(Tokens.SEMICOLON) || (readMargins && this._margin())){
                            //noop
                        } else if (this._declaration()){
                            if (!tokenStream.match(Tokens.SEMICOLON)){
                                break;
                            }
                        } else {
                            break;
                        }

                        //if ((!this._margin() && !this._declaration()) || !tokenStream.match(Tokens.SEMICOLON)){
                        //    break;
                        //}
                        this._readWhitespace();
                    }

                    tokenStream.mustMatch(Tokens.RBRACE);
                    this._readWhitespace();

                } catch (ex) {
                    if (ex instanceof SyntaxError && !this.options.strict){

                        //fire error event
                        this.fire({
                            type:       "error",
                            error:      ex,
                            message:    ex.message,
                            line:       ex.line,
                            col:        ex.col
                        });

                        //see if there's another declaration
                        tt = tokenStream.advance([Tokens.SEMICOLON, Tokens.RBRACE]);
                        if (tt == Tokens.SEMICOLON){
                            //if there's a semicolon, then there might be another declaration
                            this._readDeclarations(false, readMargins);
                        } else if (tt != Tokens.RBRACE){
                            //if there's a right brace, the rule is finished so don't do anything
                            //otherwise, rethrow the error because it wasn't handled properly
                            throw ex;
                        }

                    } else {
                        //not a syntax error, rethrow it
                        throw ex;
                    }
                }

            },

            /**
             * In some cases, you can end up with two white space tokens in a
             * row. Instead of making a change in every function that looks for
             * white space, this function is used to match as much white space
             * as necessary.
             * @method _readWhitespace
             * @return {String} The white space if found, empty string if not.
             * @private
             */
            _readWhitespace: function(){

                var tokenStream = this._tokenStream,
                    ws = "";

                while(tokenStream.match(Tokens.S)){
                    ws += tokenStream.token().value;
                }

                return ws;
            },


            /**
             * Throws an error when an unexpected token is found.
             * @param {Object} token The token that was found.
             * @method _unexpectedToken
             * @return {void}
             * @private
             */
            _unexpectedToken: function(token){
                throw new SyntaxError("Unexpected token '" + token.value + "' at line " + token.startLine + ", col " + token.startCol + ".", token.startLine, token.startCol);
            },

            /**
             * Helper method used for parsing subparts of a style sheet.
             * @return {void}
             * @method _verifyEnd
             * @private
             */
            _verifyEnd: function(){
                if (this._tokenStream.LA(1) != Tokens.EOF){
                    this._unexpectedToken(this._tokenStream.LT(1));
                }
            },

            //-----------------------------------------------------------------
            // Validation methods
            //-----------------------------------------------------------------
            _validateProperty: function(property, value){
                Validation.validate(property, value);
            },

            //-----------------------------------------------------------------
            // Parsing methods
            //-----------------------------------------------------------------

            parse: function(input){
                this._tokenStream = new TokenStream(input, Tokens);
                this._stylesheet();
            },

            parseStyleSheet: function(input){
                //just passthrough
                return this.parse(input);
            },

            parseMediaQuery: function(input){
                this._tokenStream = new TokenStream(input, Tokens);
                var result = this._media_query();

                //if there's anything more, then it's an invalid selector
                this._verifyEnd();

                //otherwise return result
                return result;
            },

            /**
             * Parses a property value (everything after the semicolon).
             * @return {parserlib.css.PropertyValue} The property value.
             * @throws parserlib.util.SyntaxError If an unexpected token is found.
             * @method parserPropertyValue
             */
            parsePropertyValue: function(input){

                this._tokenStream = new TokenStream(input, Tokens);
                this._readWhitespace();

                var result = this._expr();

                //okay to have a trailing white space
                this._readWhitespace();

                //if there's anything more, then it's an invalid selector
                this._verifyEnd();

                //otherwise return result
                return result;
            },

            /**
             * Parses a complete CSS rule, including selectors and
             * properties.
             * @param {String} input The text to parser.
             * @return {Boolean} True if the parse completed successfully, false if not.
             * @method parseRule
             */
            parseRule: function(input){
                this._tokenStream = new TokenStream(input, Tokens);

                //skip any leading white space
                this._readWhitespace();

                var result = this._ruleset();

                //skip any trailing white space
                this._readWhitespace();

                //if there's anything more, then it's an invalid selector
                this._verifyEnd();

                //otherwise return result
                return result;
            },

            /**
             * Parses a single CSS selector (no comma)
             * @param {String} input The text to parse as a CSS selector.
             * @return {Selector} An object representing the selector.
             * @throws parserlib.util.SyntaxError If an unexpected token is found.
             * @method parseSelector
             */
            parseSelector: function(input){

                this._tokenStream = new TokenStream(input, Tokens);

                //skip any leading white space
                this._readWhitespace();

                var result = this._selector();

                //skip any trailing white space
                this._readWhitespace();

                //if there's anything more, then it's an invalid selector
                this._verifyEnd();

                //otherwise return result
                return result;
            },

            /**
             * Parses an HTML style attribute: a set of CSS declarations
             * separated by semicolons.
             * @param {String} input The text to parse as a style attribute
             * @return {void}
             * @method parseStyleAttribute
             */
            parseStyleAttribute: function(input){
                input += "}"; // for error recovery in _readDeclarations()
                this._tokenStream = new TokenStream(input, Tokens);
                this._readDeclarations();
            }
        };

    //copy over onto prototype
    for (prop in additions){
        if (additions.hasOwnProperty(prop)){
            proto[prop] = additions[prop];
        }
    }

    return proto;
}();


/*
nth
  : S* [ ['-'|'+']? INTEGER? {N} [ S* ['-'|'+'] S* INTEGER ]? |
         ['-'|'+']? INTEGER | {O}{D}{D} | {E}{V}{E}{N} ] S*
  ;
*/
/*global Validation, ValidationTypes, ValidationError*/
var Properties = {

    //A
    "align-items"                   : "flex-start | flex-end | center | baseline | stretch",
    "align-content"                 : "flex-start | flex-end | center | space-between | space-around | stretch",
    "align-self"                    : "auto | flex-start | flex-end | center | baseline | stretch",
    "-webkit-align-items"           : "flex-start | flex-end | center | baseline | stretch",
    "-webkit-align-content"         : "flex-start | flex-end | center | space-between | space-around | stretch",
    "-webkit-align-self"            : "auto | flex-start | flex-end | center | baseline | stretch",
    "alignment-adjust"              : "auto | baseline | before-edge | text-before-edge | middle | central | after-edge | text-after-edge | ideographic | alphabetic | hanging | mathematical | <percentage> | <length>",
    "alignment-baseline"            : "baseline | use-script | before-edge | text-before-edge | after-edge | text-after-edge | central | middle | ideographic | alphabetic | hanging | mathematical",
    "animation"                     : 1,
    "animation-delay"               : { multi: "<time>", comma: true },
    "animation-direction"           : { multi: "normal | alternate", comma: true },
    "animation-duration"            : { multi: "<time>", comma: true },
    "animation-fill-mode"           : { multi: "none | forwards | backwards | both", comma: true },
    "animation-iteration-count"     : { multi: "<number> | infinite", comma: true },
    "animation-name"                : { multi: "none | <ident>", comma: true },
    "animation-play-state"          : { multi: "running | paused", comma: true },
    "animation-timing-function"     : 1,

    //vendor prefixed
    "-moz-animation-delay"               : { multi: "<time>", comma: true },
    "-moz-animation-direction"           : { multi: "normal | alternate", comma: true },
    "-moz-animation-duration"            : { multi: "<time>", comma: true },
    "-moz-animation-iteration-count"     : { multi: "<number> | infinite", comma: true },
    "-moz-animation-name"                : { multi: "none | <ident>", comma: true },
    "-moz-animation-play-state"          : { multi: "running | paused", comma: true },

    "-ms-animation-delay"               : { multi: "<time>", comma: true },
    "-ms-animation-direction"           : { multi: "normal | alternate", comma: true },
    "-ms-animation-duration"            : { multi: "<time>", comma: true },
    "-ms-animation-iteration-count"     : { multi: "<number> | infinite", comma: true },
    "-ms-animation-name"                : { multi: "none | <ident>", comma: true },
    "-ms-animation-play-state"          : { multi: "running | paused", comma: true },

    "-webkit-animation-delay"               : { multi: "<time>", comma: true },
    "-webkit-animation-direction"           : { multi: "normal | alternate", comma: true },
    "-webkit-animation-duration"            : { multi: "<time>", comma: true },
    "-webkit-animation-fill-mode"           : { multi: "none | forwards | backwards | both", comma: true },
    "-webkit-animation-iteration-count"     : { multi: "<number> | infinite", comma: true },
    "-webkit-animation-name"                : { multi: "none | <ident>", comma: true },
    "-webkit-animation-play-state"          : { multi: "running | paused", comma: true },

    "-o-animation-delay"               : { multi: "<time>", comma: true },
    "-o-animation-direction"           : { multi: "normal | alternate", comma: true },
    "-o-animation-duration"            : { multi: "<time>", comma: true },
    "-o-animation-iteration-count"     : { multi: "<number> | infinite", comma: true },
    "-o-animation-name"                : { multi: "none | <ident>", comma: true },
    "-o-animation-play-state"          : { multi: "running | paused", comma: true },

    "appearance"                    : "icon | window | desktop | workspace | document | tooltip | dialog | button | push-button | hyperlink | radio-button | checkbox | menu-item | tab | menu | menubar | pull-down-menu | pop-up-menu | list-menu | radio-group | checkbox-group | outline-tree | range | field | combo-box | signature | password | normal | none | inherit",
    "azimuth"                       : function (expression) {
        var simple      = "<angle> | leftwards | rightwards | inherit",
            direction   = "left-side | far-left | left | center-left | center | center-right | right | far-right | right-side",
            behind      = false,
            valid       = false,
            part;

        if (!ValidationTypes.isAny(expression, simple)) {
            if (ValidationTypes.isAny(expression, "behind")) {
                behind = true;
                valid = true;
            }

            if (ValidationTypes.isAny(expression, direction)) {
                valid = true;
                if (!behind) {
                    ValidationTypes.isAny(expression, "behind");
                }
            }
        }

        if (expression.hasNext()) {
            part = expression.next();
            if (valid) {
                throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
            } else {
                throw new ValidationError("Expected (<'azimuth'>) but found '" + part + "'.", part.line, part.col);
            }
        }
    },

    //B
    "backface-visibility"           : "visible | hidden",
    "background"                    : 1,
    "background-attachment"         : { multi: "<attachment>", comma: true },
    "background-clip"               : { multi: "<box>", comma: true },
    "background-color"              : "<color> | inherit",
    "background-image"              : { multi: "<bg-image>", comma: true },
    "background-origin"             : { multi: "<box>", comma: true },
    "background-position"           : { multi: "<bg-position>", comma: true },
    "background-repeat"             : { multi: "<repeat-style>" },
    "background-size"               : { multi: "<bg-size>", comma: true },
    "baseline-shift"                : "baseline | sub | super | <percentage> | <length>",
    "behavior"                      : 1,
    "binding"                       : 1,
    "bleed"                         : "<length>",
    "bookmark-label"                : "<content> | <attr> | <string>",
    "bookmark-level"                : "none | <integer>",
    "bookmark-state"                : "open | closed",
    "bookmark-target"               : "none | <uri> | <attr>",
    "border"                        : "<border-width> || <border-style> || <color>",
    "border-bottom"                 : "<border-width> || <border-style> || <color>",
    "border-bottom-color"           : "<color> | inherit",
    "border-bottom-left-radius"     :  "<x-one-radius>",
    "border-bottom-right-radius"    :  "<x-one-radius>",
    "border-bottom-style"           : "<border-style>",
    "border-bottom-width"           : "<border-width>",
    "border-collapse"               : "collapse | separate | inherit",
    "border-color"                  : { multi: "<color> | inherit", max: 4 },
    "border-image"                  : 1,
    "border-image-outset"           : { multi: "<length> | <number>", max: 4 },
    "border-image-repeat"           : { multi: "stretch | repeat | round", max: 2 },
    "border-image-slice"            : function(expression) {

        var valid   = false,
            numeric = "<number> | <percentage>",
            fill    = false,
            count   = 0,
            max     = 4,
            part;

        if (ValidationTypes.isAny(expression, "fill")) {
            fill = true;
            valid = true;
        }

        while (expression.hasNext() && count < max) {
            valid = ValidationTypes.isAny(expression, numeric);
            if (!valid) {
                break;
            }
            count++;
        }


        if (!fill) {
            ValidationTypes.isAny(expression, "fill");
        } else {
            valid = true;
        }

        if (expression.hasNext()) {
            part = expression.next();
            if (valid) {
                throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
            } else {
                throw new ValidationError("Expected ([<number> | <percentage>]{1,4} && fill?) but found '" + part + "'.", part.line, part.col);
            }
        }
    },
    "border-image-source"           : "<image> | none",
    "border-image-width"            : { multi: "<length> | <percentage> | <number> | auto", max: 4 },
    "border-left"                   : "<border-width> || <border-style> || <color>",
    "border-left-color"             : "<color> | inherit",
    "border-left-style"             : "<border-style>",
    "border-left-width"             : "<border-width>",
    "border-radius"                 : function(expression) {

        var valid   = false,
            simple = "<length> | <percentage> | inherit",
            slash   = false,
            fill    = false,
            count   = 0,
            max     = 8,
            part;

        while (expression.hasNext() && count < max) {
            valid = ValidationTypes.isAny(expression, simple);
            if (!valid) {

                if (expression.peek() == "/" && count > 0 && !slash) {
                    slash = true;
                    max = count + 5;
                    expression.next();
                } else {
                    break;
                }
            }
            count++;
        }

        if (expression.hasNext()) {
            part = expression.next();
            if (valid) {
                throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
            } else {
                throw new ValidationError("Expected (<'border-radius'>) but found '" + part + "'.", part.line, part.col);
            }
        }
    },
    "border-right"                  : "<border-width> || <border-style> || <color>",
    "border-right-color"            : "<color> | inherit",
    "border-right-style"            : "<border-style>",
    "border-right-width"            : "<border-width>",
    "border-spacing"                : { multi: "<length> | inherit", max: 2 },
    "border-style"                  : { multi: "<border-style>", max: 4 },
    "border-top"                    : "<border-width> || <border-style> || <color>",
    "border-top-color"              : "<color> | inherit",
    "border-top-left-radius"        : "<x-one-radius>",
    "border-top-right-radius"       : "<x-one-radius>",
    "border-top-style"              : "<border-style>",
    "border-top-width"              : "<border-width>",
    "border-width"                  : { multi: "<border-width>", max: 4 },
    "bottom"                        : "<margin-width> | inherit",
    "-moz-box-align"                : "start | end | center | baseline | stretch",
    "-moz-box-decoration-break"     : "slice |clone",
    "-moz-box-direction"            : "normal | reverse | inherit",
    "-moz-box-flex"                 : "<number>",
    "-moz-box-flex-group"           : "<integer>",
    "-moz-box-lines"                : "single | multiple",
    "-moz-box-ordinal-group"        : "<integer>",
    "-moz-box-orient"               : "horizontal | vertical | inline-axis | block-axis | inherit",
    "-moz-box-pack"                 : "start | end | center | justify",
    "-webkit-box-align"             : "start | end | center | baseline | stretch",
    "-webkit-box-decoration-break"  : "slice |clone",
    "-webkit-box-direction"         : "normal | reverse | inherit",
    "-webkit-box-flex"              : "<number>",
    "-webkit-box-flex-group"        : "<integer>",
    "-webkit-box-lines"             : "single | multiple",
    "-webkit-box-ordinal-group"     : "<integer>",
    "-webkit-box-orient"            : "horizontal | vertical | inline-axis | block-axis | inherit",
    "-webkit-box-pack"              : "start | end | center | justify",
    "box-shadow"                    : function (expression) {
        var result      = false,
            part;

        if (!ValidationTypes.isAny(expression, "none")) {
            Validation.multiProperty("<shadow>", expression, true, Infinity);
        } else {
            if (expression.hasNext()) {
                part = expression.next();
                throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
            }
        }
    },
    "box-sizing"                    : "content-box | border-box | inherit",
    "break-after"                   : "auto | always | avoid | left | right | page | column | avoid-page | avoid-column",
    "break-before"                  : "auto | always | avoid | left | right | page | column | avoid-page | avoid-column",
    "break-inside"                  : "auto | avoid | avoid-page | avoid-column",

    //C
    "caption-side"                  : "top | bottom | inherit",
    "clear"                         : "none | right | left | both | inherit",
    "clip"                          : 1,
    "color"                         : "<color> | inherit",
    "color-profile"                 : 1,
    "column-count"                  : "<integer> | auto",                      //http://www.w3.org/TR/css3-multicol/
    "column-fill"                   : "auto | balance",
    "column-gap"                    : "<length> | normal",
    "column-rule"                   : "<border-width> || <border-style> || <color>",
    "column-rule-color"             : "<color>",
    "column-rule-style"             : "<border-style>",
    "column-rule-width"             : "<border-width>",
    "column-span"                   : "none | all",
    "column-width"                  : "<length> | auto",
    "columns"                       : 1,
    "content"                       : 1,
    "counter-increment"             : 1,
    "counter-reset"                 : 1,
    "crop"                          : "<shape> | auto",
    "cue"                           : "cue-after | cue-before | inherit",
    "cue-after"                     : 1,
    "cue-before"                    : 1,
    "cursor"                        : 1,

    //D
    "direction"                     : "ltr | rtl | inherit",
    "display"                       : "inline | block | list-item | inline-block | table | inline-table | table-row-group | table-header-group | table-footer-group | table-row | table-column-group | table-column | table-cell | table-caption | grid | inline-grid | none | inherit | -moz-box | -moz-inline-block | -moz-inline-box | -moz-inline-grid | -moz-inline-stack | -moz-inline-table | -moz-grid | -moz-grid-group | -moz-grid-line | -moz-groupbox | -moz-deck | -moz-popup | -moz-stack | -moz-marker | -webkit-box | -webkit-inline-box | -ms-flexbox | -ms-inline-flexbox | flex | -webkit-flex | inline-flex | -webkit-inline-flex",
    "dominant-baseline"             : 1,
    "drop-initial-after-adjust"     : "central | middle | after-edge | text-after-edge | ideographic | alphabetic | mathematical | <percentage> | <length>",
    "drop-initial-after-align"      : "baseline | use-script | before-edge | text-before-edge | after-edge | text-after-edge | central | middle | ideographic | alphabetic | hanging | mathematical",
    "drop-initial-before-adjust"    : "before-edge | text-before-edge | central | middle | hanging | mathematical | <percentage> | <length>",
    "drop-initial-before-align"     : "caps-height | baseline | use-script | before-edge | text-before-edge | after-edge | text-after-edge | central | middle | ideographic | alphabetic | hanging | mathematical",
    "drop-initial-size"             : "auto | line | <length> | <percentage>",
    "drop-initial-value"            : "initial | <integer>",

    //E
    "elevation"                     : "<angle> | below | level | above | higher | lower | inherit",
    "empty-cells"                   : "show | hide | inherit",

    //F
    "fill"                          : "<color>",
    "filter"                        : 1,
    "fit"                           : "fill | hidden | meet | slice",
    "fit-position"                  : 1,
    "flex"                          : "<flex>",
    "flex-basis"                    : "<width>",
    "flex-direction"                : "row | row-reverse | column | column-reverse",
    "flex-flow"                     : "<flex-direction> || <flex-wrap>",
    "flex-grow"                     : "<number>",
    "flex-shrink"                   : "<number>",
    "flex-wrap"                     : "nowrap | wrap | wrap-reverse",
    "-webkit-flex"                  : "<flex>",
    "-webkit-flex-basis"            : "<width>",
    "-webkit-flex-direction"        : "row | row-reverse | column | column-reverse",
    "-webkit-flex-flow"             : "<flex-direction> || <flex-wrap>",
    "-webkit-flex-grow"             : "<number>",
    "-webkit-flex-shrink"           : "<number>",
    "-webkit-flex-wrap"             : "nowrap | wrap | wrap-reverse",
    "-ms-flex"                      : "<flex>",
    "-ms-flex-align"                : "start | end | center | stretch | baseline",
    "-ms-flex-direction"            : "row | row-reverse | column | column-reverse | inherit",
    "-ms-flex-order"                : "<number>",
    "-ms-flex-pack"                 : "start | end | center | justify",
    "-ms-flex-wrap"                 : "nowrap | wrap | wrap-reverse",
    "float"                         : "left | right | none | inherit",
    "float-offset"                  : 1,
    "font"                          : 1,
    "font-family"                   : 1,
    "font-size"                     : "<absolute-size> | <relative-size> | <length> | <percentage> | inherit",
    "font-size-adjust"              : "<number> | none | inherit",
    "font-stretch"                  : "normal | ultra-condensed | extra-condensed | condensed | semi-condensed | semi-expanded | expanded | extra-expanded | ultra-expanded | inherit",
    "font-style"                    : "normal | italic | oblique | inherit",
    "font-variant"                  : "normal | small-caps | inherit",
    "font-weight"                   : "normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit",

    //G
    "grid-cell-stacking"            : "columns | rows | layer",
    "grid-column"                   : 1,
    "grid-columns"                  : 1,
    "grid-column-align"             : "start | end | center | stretch",
    "grid-column-sizing"            : 1,
    "grid-column-span"              : "<integer>",
    "grid-flow"                     : "none | rows | columns",
    "grid-layer"                    : "<integer>",
    "grid-row"                      : 1,
    "grid-rows"                     : 1,
    "grid-row-align"                : "start | end | center | stretch",
    "grid-row-span"                 : "<integer>",
    "grid-row-sizing"               : 1,

    //H
    "hanging-punctuation"           : 1,
    "height"                        : "<margin-width> | <content-sizing> | inherit",
    "hyphenate-after"               : "<integer> | auto",
    "hyphenate-before"              : "<integer> | auto",
    "hyphenate-character"           : "<string> | auto",
    "hyphenate-lines"               : "no-limit | <integer>",
    "hyphenate-resource"            : 1,
    "hyphens"                       : "none | manual | auto",

    //I
    "icon"                          : 1,
    "image-orientation"             : "angle | auto",
    "image-rendering"               : 1,
    "image-resolution"              : 1,
    "inline-box-align"              : "initial | last | <integer>",

    //J
    "justify-content"               : "flex-start | flex-end | center | space-between | space-around",
    "-webkit-justify-content"       : "flex-start | flex-end | center | space-between | space-around",

    //L
    "left"                          : "<margin-width> | inherit",
    "letter-spacing"                : "<length> | normal | inherit",
    "line-height"                   : "<number> | <length> | <percentage> | normal | inherit",
    "line-break"                    : "auto | loose | normal | strict",
    "line-stacking"                 : 1,
    "line-stacking-ruby"            : "exclude-ruby | include-ruby",
    "line-stacking-shift"           : "consider-shifts | disregard-shifts",
    "line-stacking-strategy"        : "inline-line-height | block-line-height | max-height | grid-height",
    "list-style"                    : 1,
    "list-style-image"              : "<uri> | none | inherit",
    "list-style-position"           : "inside | outside | inherit",
    "list-style-type"               : "disc | circle | square | decimal | decimal-leading-zero | lower-roman | upper-roman | lower-greek | lower-latin | upper-latin | armenian | georgian | lower-alpha | upper-alpha | none | inherit",

    //M
    "margin"                        : { multi: "<margin-width> | inherit", max: 4 },
    "margin-bottom"                 : "<margin-width> | inherit",
    "margin-left"                   : "<margin-width> | inherit",
    "margin-right"                  : "<margin-width> | inherit",
    "margin-top"                    : "<margin-width> | inherit",
    "mark"                          : 1,
    "mark-after"                    : 1,
    "mark-before"                   : 1,
    "marks"                         : 1,
    "marquee-direction"             : 1,
    "marquee-play-count"            : 1,
    "marquee-speed"                 : 1,
    "marquee-style"                 : 1,
    "max-height"                    : "<length> | <percentage> | <content-sizing> | none | inherit",
    "max-width"                     : "<length> | <percentage> | <content-sizing> | none | inherit",
    "min-height"                    : "<length> | <percentage> | <content-sizing> | contain-floats | -moz-contain-floats | -webkit-contain-floats | inherit",
    "min-width"                     : "<length> | <percentage> | <content-sizing> | contain-floats | -moz-contain-floats | -webkit-contain-floats | inherit",
    "move-to"                       : 1,

    //N
    "nav-down"                      : 1,
    "nav-index"                     : 1,
    "nav-left"                      : 1,
    "nav-right"                     : 1,
    "nav-up"                        : 1,

    //O
    "opacity"                       : "<number> | inherit",
    "order"                         : "<integer>",
    "-webkit-order"                 : "<integer>",
    "orphans"                       : "<integer> | inherit",
    "outline"                       : 1,
    "outline-color"                 : "<color> | invert | inherit",
    "outline-offset"                : 1,
    "outline-style"                 : "<border-style> | inherit",
    "outline-width"                 : "<border-width> | inherit",
    "overflow"                      : "visible | hidden | scroll | auto | inherit",
    "overflow-style"                : 1,
    "overflow-wrap"                 : "normal | break-word",
    "overflow-x"                    : 1,
    "overflow-y"                    : 1,

    //P
    "padding"                       : { multi: "<padding-width> | inherit", max: 4 },
    "padding-bottom"                : "<padding-width> | inherit",
    "padding-left"                  : "<padding-width> | inherit",
    "padding-right"                 : "<padding-width> | inherit",
    "padding-top"                   : "<padding-width> | inherit",
    "page"                          : 1,
    "page-break-after"              : "auto | always | avoid | left | right | inherit",
    "page-break-before"             : "auto | always | avoid | left | right | inherit",
    "page-break-inside"             : "auto | avoid | inherit",
    "page-policy"                   : 1,
    "pause"                         : 1,
    "pause-after"                   : 1,
    "pause-before"                  : 1,
    "perspective"                   : 1,
    "perspective-origin"            : 1,
    "phonemes"                      : 1,
    "pitch"                         : 1,
    "pitch-range"                   : 1,
    "play-during"                   : 1,
    "pointer-events"                : "auto | none | visiblePainted | visibleFill | visibleStroke | visible | painted | fill | stroke | all | inherit",
    "position"                      : "static | relative | absolute | fixed | inherit",
    "presentation-level"            : 1,
    "punctuation-trim"              : 1,

    //Q
    "quotes"                        : 1,

    //R
    "rendering-intent"              : 1,
    "resize"                        : 1,
    "rest"                          : 1,
    "rest-after"                    : 1,
    "rest-before"                   : 1,
    "richness"                      : 1,
    "right"                         : "<margin-width> | inherit",
    "rotation"                      : 1,
    "rotation-point"                : 1,
    "ruby-align"                    : 1,
    "ruby-overhang"                 : 1,
    "ruby-position"                 : 1,
    "ruby-span"                     : 1,

    //S
    "size"                          : 1,
    "speak"                         : "normal | none | spell-out | inherit",
    "speak-header"                  : "once | always | inherit",
    "speak-numeral"                 : "digits | continuous | inherit",
    "speak-punctuation"             : "code | none | inherit",
    "speech-rate"                   : 1,
    "src"                           : 1,
    "stress"                        : 1,
    "string-set"                    : 1,

    "stroke"                        : 1,
    "stroke-dasharray"              : 1,

    "table-layout"                  : "auto | fixed | inherit",
    "tab-size"                      : "<integer> | <length>",
    "target"                        : 1,
    "target-name"                   : 1,
    "target-new"                    : 1,
    "target-position"               : 1,
    "text-align"                    : "left | right | center | justify | inherit" ,
    "text-align-last"               : 1,
    "text-decoration"               : 1,
    "text-emphasis"                 : 1,
    "text-height"                   : 1,
    "text-indent"                   : "<length> | <percentage> | inherit",
    "text-justify"                  : "auto | none | inter-word | inter-ideograph | inter-cluster | distribute | kashida",
    "text-outline"                  : 1,
    "text-overflow"                 : 1,
    "text-rendering"                : "auto | optimizeSpeed | optimizeLegibility | geometricPrecision | inherit",
    "text-shadow"                   : 1,
    "text-transform"                : "capitalize | uppercase | lowercase | none | inherit",
    "text-wrap"                     : "normal | none | avoid",
    "top"                           : "<margin-width> | inherit",
    "-ms-touch-action"              : "auto | none | pan-x | pan-y",
    "touch-action"                  : "auto | none | pan-x | pan-y",
    "transform"                     : 1,
    "transform-origin"              : 1,
    "transform-style"               : 1,
    "transition"                    : 1,
    "transition-delay"              : 1,
    "transition-duration"           : 1,
    "transition-property"           : 1,
    "transition-timing-function"    : 1,

    //U
    "unicode-bidi"                  : "normal | embed | isolate | bidi-override | isolate-override | plaintext | inherit",
    "user-modify"                   : "read-only | read-write | write-only | inherit",
    "user-select"                   : "none | text | toggle | element | elements | all | inherit",

    //V
    "vertical-align"                : "auto | use-script | baseline | sub | super | top | text-top | central | middle | bottom | text-bottom | <percentage> | <length>",
    "visibility"                    : "visible | hidden | collapse | inherit",
    "voice-balance"                 : 1,
    "voice-duration"                : 1,
    "voice-family"                  : 1,
    "voice-pitch"                   : 1,
    "voice-pitch-range"             : 1,
    "voice-rate"                    : 1,
    "voice-stress"                  : 1,
    "voice-volume"                  : 1,
    "volume"                        : 1,

    //W
    "white-space"                   : "normal | pre | nowrap | pre-wrap | pre-line | inherit | -pre-wrap | -o-pre-wrap | -moz-pre-wrap | -hp-pre-wrap", //http://perishablepress.com/wrapping-content/
    "white-space-collapse"          : 1,
    "widows"                        : "<integer> | inherit",
    "width"                         : "<length> | <percentage> | <content-sizing> | auto | inherit",
    "will-change"                   : 1,
    "word-break"                    : "normal | keep-all | break-all",
    "word-spacing"                  : "<length> | normal | inherit",
    "word-wrap"                     : "normal | break-word",
    "writing-mode"                  : "horizontal-tb | vertical-rl | vertical-lr | lr-tb | rl-tb | tb-rl | bt-rl | tb-lr | bt-lr | lr-bt | rl-bt | lr | rl | tb | inherit",

    //Z
    "z-index"                       : "<integer> | auto | inherit",
    "zoom"                          : "<number> | <percentage> | normal"
};
/*global SyntaxUnit, Parser*/
/**
 * Represents a selector combinator (whitespace, +, >).
 * @namespace parserlib.css
 * @class PropertyName
 * @extends parserlib.util.SyntaxUnit
 * @constructor
 * @param {String} text The text representation of the unit.
 * @param {String} hack The type of IE hack applied ("*", "_", or null).
 * @param {int} line The line of text on which the unit resides.
 * @param {int} col The column of text on which the unit resides.
 */
function PropertyName(text, hack, line, col){

    SyntaxUnit.call(this, text, line, col, Parser.PROPERTY_NAME_TYPE);

    /**
     * The type of IE hack applied ("*", "_", or null).
     * @type String
     * @property hack
     */
    this.hack = hack;

}

PropertyName.prototype = new SyntaxUnit();
PropertyName.prototype.constructor = PropertyName;
PropertyName.prototype.toString = function(){
    return (this.hack ? this.hack : "") + this.text;
};
/*global SyntaxUnit, Parser*/
/**
 * Represents a single part of a CSS property value, meaning that it represents
 * just everything single part between ":" and ";". If there are multiple values
 * separated by commas, this type represents just one of the values.
 * @param {String[]} parts An array of value parts making up this value.
 * @param {int} line The line of text on which the unit resides.
 * @param {int} col The column of text on which the unit resides.
 * @namespace parserlib.css
 * @class PropertyValue
 * @extends parserlib.util.SyntaxUnit
 * @constructor
 */
function PropertyValue(parts, line, col){

    SyntaxUnit.call(this, parts.join(" "), line, col, Parser.PROPERTY_VALUE_TYPE);

    /**
     * The parts that make up the selector.
     * @type Array
     * @property parts
     */
    this.parts = parts;

}

PropertyValue.prototype = new SyntaxUnit();
PropertyValue.prototype.constructor = PropertyValue;

/*global SyntaxUnit, Parser*/
/**
 * A utility class that allows for easy iteration over the various parts of a
 * property value.
 * @param {parserlib.css.PropertyValue} value The property value to iterate over.
 * @namespace parserlib.css
 * @class PropertyValueIterator
 * @constructor
 */
function PropertyValueIterator(value){

    /**
     * Iterator value
     * @type int
     * @property _i
     * @private
     */
    this._i = 0;

    /**
     * The parts that make up the value.
     * @type Array
     * @property _parts
     * @private
     */
    this._parts = value.parts;

    /**
     * Keeps track of bookmarks along the way.
     * @type Array
     * @property _marks
     * @private
     */
    this._marks = [];

    /**
     * Holds the original property value.
     * @type parserlib.css.PropertyValue
     * @property value
     */
    this.value = value;

}

/**
 * Returns the total number of parts in the value.
 * @return {int} The total number of parts in the value.
 * @method count
 */
PropertyValueIterator.prototype.count = function(){
    return this._parts.length;
};

/**
 * Indicates if the iterator is positioned at the first item.
 * @return {Boolean} True if positioned at first item, false if not.
 * @method isFirst
 */
PropertyValueIterator.prototype.isFirst = function(){
    return this._i === 0;
};

/**
 * Indicates if there are more parts of the property value.
 * @return {Boolean} True if there are more parts, false if not.
 * @method hasNext
 */
PropertyValueIterator.prototype.hasNext = function(){
    return (this._i < this._parts.length);
};

/**
 * Marks the current spot in the iteration so it can be restored to
 * later on.
 * @return {void}
 * @method mark
 */
PropertyValueIterator.prototype.mark = function(){
    this._marks.push(this._i);
};

/**
 * Returns the next part of the property value or null if there is no next
 * part. Does not move the internal counter forward.
 * @return {parserlib.css.PropertyValuePart} The next part of the property value or null if there is no next
 * part.
 * @method peek
 */
PropertyValueIterator.prototype.peek = function(count){
    return this.hasNext() ? this._parts[this._i + (count || 0)] : null;
};

/**
 * Returns the next part of the property value or null if there is no next
 * part.
 * @return {parserlib.css.PropertyValuePart} The next part of the property value or null if there is no next
 * part.
 * @method next
 */
PropertyValueIterator.prototype.next = function(){
    return this.hasNext() ? this._parts[this._i++] : null;
};

/**
 * Returns the previous part of the property value or null if there is no
 * previous part.
 * @return {parserlib.css.PropertyValuePart} The previous part of the
 * property value or null if there is no next part.
 * @method previous
 */
PropertyValueIterator.prototype.previous = function(){
    return this._i > 0 ? this._parts[--this._i] : null;
};

/**
 * Restores the last saved bookmark.
 * @return {void}
 * @method restore
 */
PropertyValueIterator.prototype.restore = function(){
    if (this._marks.length){
        this._i = this._marks.pop();
    }
};

/*global SyntaxUnit, Parser, Colors*/
/**
 * Represents a single part of a CSS property value, meaning that it represents
 * just one part of the data between ":" and ";".
 * @param {String} text The text representation of the unit.
 * @param {int} line The line of text on which the unit resides.
 * @param {int} col The column of text on which the unit resides.
 * @namespace parserlib.css
 * @class PropertyValuePart
 * @extends parserlib.util.SyntaxUnit
 * @constructor
 */
function PropertyValuePart(text, line, col){

    SyntaxUnit.call(this, text, line, col, Parser.PROPERTY_VALUE_PART_TYPE);

    /**
     * Indicates the type of value unit.
     * @type String
     * @property type
     */
    this.type = "unknown";

    //figure out what type of data it is

    var temp;

    //it is a measurement?
    if (/^([+\-]?[\d\.]+)([a-z]+)$/i.test(text)){  //dimension
        this.type = "dimension";
        this.value = +RegExp.$1;
        this.units = RegExp.$2;

        //try to narrow down
        switch(this.units.toLowerCase()){

            case "em":
            case "rem":
            case "ex":
            case "px":
            case "cm":
            case "mm":
            case "in":
            case "pt":
            case "pc":
            case "ch":
            case "vh":
            case "vw":
            case "vmax":
            case "vmin":
                this.type = "length";
                break;

            case "deg":
            case "rad":
            case "grad":
                this.type = "angle";
                break;

            case "ms":
            case "s":
                this.type = "time";
                break;

            case "hz":
            case "khz":
                this.type = "frequency";
                break;

            case "dpi":
            case "dpcm":
                this.type = "resolution";
                break;

            //default

        }

    } else if (/^([+\-]?[\d\.]+)%$/i.test(text)){  //percentage
        this.type = "percentage";
        this.value = +RegExp.$1;
    } else if (/^([+\-]?\d+)$/i.test(text)){  //integer
        this.type = "integer";
        this.value = +RegExp.$1;
    } else if (/^([+\-]?[\d\.]+)$/i.test(text)){  //number
        this.type = "number";
        this.value = +RegExp.$1;

    } else if (/^#([a-f0-9]{3,6})/i.test(text)){  //hexcolor
        this.type = "color";
        temp = RegExp.$1;
        if (temp.length == 3){
            this.red    = parseInt(temp.charAt(0)+temp.charAt(0),16);
            this.green  = parseInt(temp.charAt(1)+temp.charAt(1),16);
            this.blue   = parseInt(temp.charAt(2)+temp.charAt(2),16);
        } else {
            this.red    = parseInt(temp.substring(0,2),16);
            this.green  = parseInt(temp.substring(2,4),16);
            this.blue   = parseInt(temp.substring(4,6),16);
        }
    } else if (/^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/i.test(text)){ //rgb() color with absolute numbers
        this.type   = "color";
        this.red    = +RegExp.$1;
        this.green  = +RegExp.$2;
        this.blue   = +RegExp.$3;
    } else if (/^rgb\(\s*(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)/i.test(text)){ //rgb() color with percentages
        this.type   = "color";
        this.red    = +RegExp.$1 * 255 / 100;
        this.green  = +RegExp.$2 * 255 / 100;
        this.blue   = +RegExp.$3 * 255 / 100;
    } else if (/^rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([\d\.]+)\s*\)/i.test(text)){ //rgba() color with absolute numbers
        this.type   = "color";
        this.red    = +RegExp.$1;
        this.green  = +RegExp.$2;
        this.blue   = +RegExp.$3;
        this.alpha  = +RegExp.$4;
    } else if (/^rgba\(\s*(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*,\s*([\d\.]+)\s*\)/i.test(text)){ //rgba() color with percentages
        this.type   = "color";
        this.red    = +RegExp.$1 * 255 / 100;
        this.green  = +RegExp.$2 * 255 / 100;
        this.blue   = +RegExp.$3 * 255 / 100;
        this.alpha  = +RegExp.$4;
    } else if (/^hsl\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)/i.test(text)){ //hsl()
        this.type   = "color";
        this.hue    = +RegExp.$1;
        this.saturation = +RegExp.$2 / 100;
        this.lightness  = +RegExp.$3 / 100;
    } else if (/^hsla\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*,\s*([\d\.]+)\s*\)/i.test(text)){ //hsla() color with percentages
        this.type   = "color";
        this.hue    = +RegExp.$1;
        this.saturation = +RegExp.$2 / 100;
        this.lightness  = +RegExp.$3 / 100;
        this.alpha  = +RegExp.$4;
    } else if (/^url\(["']?([^\)"']+)["']?\)/i.test(text)){ //URI
        this.type   = "uri";
        this.uri    = RegExp.$1;
    } else if (/^([^\(]+)\(/i.test(text)){
        this.type   = "function";
        this.name   = RegExp.$1;
        this.value  = text;
    } else if (/^["'][^"']*["']/.test(text)){    //string
        this.type   = "string";
        this.value  = eval(text);
    } else if (Colors[text.toLowerCase()]){  //named color
        this.type   = "color";
        temp        = Colors[text.toLowerCase()].substring(1);
        this.red    = parseInt(temp.substring(0,2),16);
        this.green  = parseInt(temp.substring(2,4),16);
        this.blue   = parseInt(temp.substring(4,6),16);
    } else if (/^[\,\/]$/.test(text)){
        this.type   = "operator";
        this.value  = text;
    } else if (/^[a-z\-_\u0080-\uFFFF][a-z0-9\-_\u0080-\uFFFF]*$/i.test(text)){
        this.type   = "identifier";
        this.value  = text;
    }

}

PropertyValuePart.prototype = new SyntaxUnit();
PropertyValuePart.prototype.constructor = PropertyValuePart;

/**
 * Create a new syntax unit based solely on the given token.
 * Convenience method for creating a new syntax unit when
 * it represents a single token instead of multiple.
 * @param {Object} token The token object to represent.
 * @return {parserlib.css.PropertyValuePart} The object representing the token.
 * @static
 * @method fromToken
 */
PropertyValuePart.fromToken = function(token){
    return new PropertyValuePart(token.value, token.startLine, token.startCol);
};
var Pseudos = {
    ":first-letter": 1,
    ":first-line":   1,
    ":before":       1,
    ":after":        1
};

Pseudos.ELEMENT = 1;
Pseudos.CLASS = 2;

Pseudos.isElement = function(pseudo){
    return pseudo.indexOf("::") === 0 || Pseudos[pseudo.toLowerCase()] == Pseudos.ELEMENT;
};
/*global SyntaxUnit, Parser, Specificity*/
/**
 * Represents an entire single selector, including all parts but not
 * including multiple selectors (those separated by commas).
 * @namespace parserlib.css
 * @class Selector
 * @extends parserlib.util.SyntaxUnit
 * @constructor
 * @param {Array} parts Array of selectors parts making up this selector.
 * @param {int} line The line of text on which the unit resides.
 * @param {int} col The column of text on which the unit resides.
 */
function Selector(parts, line, col){

    SyntaxUnit.call(this, parts.join(" "), line, col, Parser.SELECTOR_TYPE);

    /**
     * The parts that make up the selector.
     * @type Array
     * @property parts
     */
    this.parts = parts;

    /**
     * The specificity of the selector.
     * @type parserlib.css.Specificity
     * @property specificity
     */
    this.specificity = Specificity.calculate(this);

}

Selector.prototype = new SyntaxUnit();
Selector.prototype.constructor = Selector;

/*global SyntaxUnit, Parser*/
/**
 * Represents a single part of a selector string, meaning a single set of
 * element name and modifiers. This does not include combinators such as
 * spaces, +, >, etc.
 * @namespace parserlib.css
 * @class SelectorPart
 * @extends parserlib.util.SyntaxUnit
 * @constructor
 * @param {String} elementName The element name in the selector or null
 *      if there is no element name.
 * @param {Array} modifiers Array of individual modifiers for the element.
 *      May be empty if there are none.
 * @param {String} text The text representation of the unit.
 * @param {int} line The line of text on which the unit resides.
 * @param {int} col The column of text on which the unit resides.
 */
function SelectorPart(elementName, modifiers, text, line, col){

    SyntaxUnit.call(this, text, line, col, Parser.SELECTOR_PART_TYPE);

    /**
     * The tag name of the element to which this part
     * of the selector affects.
     * @type String
     * @property elementName
     */
    this.elementName = elementName;

    /**
     * The parts that come after the element name, such as class names, IDs,
     * pseudo classes/elements, etc.
     * @type Array
     * @property modifiers
     */
    this.modifiers = modifiers;

}

SelectorPart.prototype = new SyntaxUnit();
SelectorPart.prototype.constructor = SelectorPart;

/*global SyntaxUnit, Parser*/
/**
 * Represents a selector modifier string, meaning a class name, element name,
 * element ID, pseudo rule, etc.
 * @namespace parserlib.css
 * @class SelectorSubPart
 * @extends parserlib.util.SyntaxUnit
 * @constructor
 * @param {String} text The text representation of the unit.
 * @param {String} type The type of selector modifier.
 * @param {int} line The line of text on which the unit resides.
 * @param {int} col The column of text on which the unit resides.
 */
function SelectorSubPart(text, type, line, col){

    SyntaxUnit.call(this, text, line, col, Parser.SELECTOR_SUB_PART_TYPE);

    /**
     * The type of modifier.
     * @type String
     * @property type
     */
    this.type = type;

    /**
     * Some subparts have arguments, this represents them.
     * @type Array
     * @property args
     */
    this.args = [];

}

SelectorSubPart.prototype = new SyntaxUnit();
SelectorSubPart.prototype.constructor = SelectorSubPart;

/*global Pseudos, SelectorPart*/
/**
 * Represents a selector's specificity.
 * @namespace parserlib.css
 * @class Specificity
 * @constructor
 * @param {int} a Should be 1 for inline styles, zero for stylesheet styles
 * @param {int} b Number of ID selectors
 * @param {int} c Number of classes and pseudo classes
 * @param {int} d Number of element names and pseudo elements
 */
function Specificity(a, b, c, d){
    this.a = a;
    this.b = b;
    this.c = c;
    this.d = d;
}

Specificity.prototype = {
    constructor: Specificity,

    /**
     * Compare this specificity to another.
     * @param {Specificity} other The other specificity to compare to.
     * @return {int} -1 if the other specificity is larger, 1 if smaller, 0 if equal.
     * @method compare
     */
    compare: function(other){
        var comps = ["a", "b", "c", "d"],
            i, len;

        for (i=0, len=comps.length; i < len; i++){
            if (this[comps[i]] < other[comps[i]]){
                return -1;
            } else if (this[comps[i]] > other[comps[i]]){
                return 1;
            }
        }

        return 0;
    },

    /**
     * Creates a numeric value for the specificity.
     * @return {int} The numeric value for the specificity.
     * @method valueOf
     */
    valueOf: function(){
        return (this.a * 1000) + (this.b * 100) + (this.c * 10) + this.d;
    },

    /**
     * Returns a string representation for specificity.
     * @return {String} The string representation of specificity.
     * @method toString
     */
    toString: function(){
        return this.a + "," + this.b + "," + this.c + "," + this.d;
    }

};

/**
 * Calculates the specificity of the given selector.
 * @param {parserlib.css.Selector} The selector to calculate specificity for.
 * @return {parserlib.css.Specificity} The specificity of the selector.
 * @static
 * @method calculate
 */
Specificity.calculate = function(selector){

    var i, len,
        part,
        b=0, c=0, d=0;

    function updateValues(part){

        var i, j, len, num,
            elementName = part.elementName ? part.elementName.text : "",
            modifier;

        if (elementName && elementName.charAt(elementName.length-1) != "*") {
            d++;
        }

        for (i=0, len=part.modifiers.length; i < len; i++){
            modifier = part.modifiers[i];
            switch(modifier.type){
                case "class":
                case "attribute":
                    c++;
                    break;

                case "id":
                    b++;
                    break;

                case "pseudo":
                    if (Pseudos.isElement(modifier.text)){
                        d++;
                    } else {
                        c++;
                    }
                    break;

                case "not":
                    for (j=0, num=modifier.args.length; j < num; j++){
                        updateValues(modifier.args[j]);
                    }
            }
         }
    }

    for (i=0, len=selector.parts.length; i < len; i++){
        part = selector.parts[i];

        if (part instanceof SelectorPart){
            updateValues(part);
        }
    }

    return new Specificity(0, b, c, d);
};
/*global Tokens, TokenStreamBase*/

var h = /^[0-9a-fA-F]$/,
    nonascii = /^[\u0080-\uFFFF]$/,
    nl = /\n|\r\n|\r|\f/;

//-----------------------------------------------------------------------------
// Helper functions
//-----------------------------------------------------------------------------


function isHexDigit(c){
    return c !== null && h.test(c);
}

function isDigit(c){
    return c !== null && /\d/.test(c);
}

function isWhitespace(c){
    return c !== null && /\s/.test(c);
}

function isNewLine(c){
    return c !== null && nl.test(c);
}

function isNameStart(c){
    return c !== null && (/[a-z_\u0080-\uFFFF\\]/i.test(c));
}

function isNameChar(c){
    return c !== null && (isNameStart(c) || /[0-9\-\\]/.test(c));
}

function isIdentStart(c){
    return c !== null && (isNameStart(c) || /\-\\/.test(c));
}

function mix(receiver, supplier){
	for (var prop in supplier){
		if (supplier.hasOwnProperty(prop)){
			receiver[prop] = supplier[prop];
		}
	}
	return receiver;
}

//-----------------------------------------------------------------------------
// CSS Token Stream
//-----------------------------------------------------------------------------


/**
 * A token stream that produces CSS tokens.
 * @param {String|Reader} input The source of text to tokenize.
 * @constructor
 * @class TokenStream
 * @namespace parserlib.css
 */
function TokenStream(input){
	TokenStreamBase.call(this, input, Tokens);
}

TokenStream.prototype = mix(new TokenStreamBase(), {

    /**
     * Overrides the TokenStreamBase method of the same name
     * to produce CSS tokens.
     * @param {variant} channel The name of the channel to use
     *      for the next token.
     * @return {Object} A token object representing the next token.
     * @method _getToken
     * @private
     */
    _getToken: function(channel){

        var c,
            reader = this._reader,
            token   = null,
            startLine   = reader.getLine(),
            startCol    = reader.getCol();

        c = reader.read();


        while(c){
            switch(c){

                /*
                 * Potential tokens:
                 * - COMMENT
                 * - SLASH
                 * - CHAR
                 */
                case "/":

                    if(reader.peek() == "*"){
                        token = this.commentToken(c, startLine, startCol);
                    } else {
                        token = this.charToken(c, startLine, startCol);
                    }
                    break;

                /*
                 * Potential tokens:
                 * - DASHMATCH
                 * - INCLUDES
                 * - PREFIXMATCH
                 * - SUFFIXMATCH
                 * - SUBSTRINGMATCH
                 * - CHAR
                 */
                case "|":
                case "~":
                case "^":
                case "$":
                case "*":
                    if(reader.peek() == "="){
                        token = this.comparisonToken(c, startLine, startCol);
                    } else {
                        token = this.charToken(c, startLine, startCol);
                    }
                    break;

                /*
                 * Potential tokens:
                 * - STRING
                 * - INVALID
                 */
                case "\"":
                case "'":
                    token = this.stringToken(c, startLine, startCol);
                    break;

                /*
                 * Potential tokens:
                 * - HASH
                 * - CHAR
                 */
                case "#":
                    if (isNameChar(reader.peek())){
                        token = this.hashToken(c, startLine, startCol);
                    } else {
                        token = this.charToken(c, startLine, startCol);
                    }
                    break;

                /*
                 * Potential tokens:
                 * - DOT
                 * - NUMBER
                 * - DIMENSION
                 * - PERCENTAGE
                 */
                case ".":
                    if (isDigit(reader.peek())){
                        token = this.numberToken(c, startLine, startCol);
                    } else {
                        token = this.charToken(c, startLine, startCol);
                    }
                    break;

                /*
                 * Potential tokens:
                 * - CDC
                 * - MINUS
                 * - NUMBER
                 * - DIMENSION
                 * - PERCENTAGE
                 */
                case "-":
                    if (reader.peek() == "-"){  //could be closing HTML-style comment
                        token = this.htmlCommentEndToken(c, startLine, startCol);
                    } else if (isNameStart(reader.peek())){
                        token = this.identOrFunctionToken(c, startLine, startCol);
                    } else {
                        token = this.charToken(c, startLine, startCol);
                    }
                    break;

                /*
                 * Potential tokens:
                 * - IMPORTANT_SYM
                 * - CHAR
                 */
                case "!":
                    token = this.importantToken(c, startLine, startCol);
                    break;

                /*
                 * Any at-keyword or CHAR
                 */
                case "@":
                    token = this.atRuleToken(c, startLine, startCol);
                    break;

                /*
                 * Potential tokens:
                 * - NOT
                 * - CHAR
                 */
                case ":":
                    token = this.notToken(c, startLine, startCol);
                    break;

                /*
                 * Potential tokens:
                 * - CDO
                 * - CHAR
                 */
                case "<":
                    token = this.htmlCommentStartToken(c, startLine, startCol);
                    break;

                /*
                 * Potential tokens:
                 * - UNICODE_RANGE
                 * - URL
                 * - CHAR
                 */
                case "U":
                case "u":
                    if (reader.peek() == "+"){
                        token = this.unicodeRangeToken(c, startLine, startCol);
                        break;
                    }
                    /* falls through */
                default:

                    /*
                     * Potential tokens:
                     * - NUMBER
                     * - DIMENSION
                     * - LENGTH
                     * - FREQ
                     * - TIME
                     * - EMS
                     * - EXS
                     * - ANGLE
                     */
                    if (isDigit(c)){
                        token = this.numberToken(c, startLine, startCol);
                    } else

                    /*
                     * Potential tokens:
                     * - S
                     */
                    if (isWhitespace(c)){
                        token = this.whitespaceToken(c, startLine, startCol);
                    } else

                    /*
                     * Potential tokens:
                     * - IDENT
                     */
                    if (isIdentStart(c)){
                        token = this.identOrFunctionToken(c, startLine, startCol);
                    } else

                    /*
                     * Potential tokens:
                     * - CHAR
                     * - PLUS
                     */
                    {
                        token = this.charToken(c, startLine, startCol);
                    }






            }

            //make sure this token is wanted
            //TODO: check channel
            break;
        }

        if (!token && c === null){
            token = this.createToken(Tokens.EOF,null,startLine,startCol);
        }

        return token;
    },

    //-------------------------------------------------------------------------
    // Methods to create tokens
    //-------------------------------------------------------------------------

    /**
     * Produces a token based on available data and the current
     * reader position information. This method is called by other
     * private methods to create tokens and is never called directly.
     * @param {int} tt The token type.
     * @param {String} value The text value of the token.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @param {Object} options (Optional) Specifies a channel property
     *      to indicate that a different channel should be scanned
     *      and/or a hide property indicating that the token should
     *      be hidden.
     * @return {Object} A token object.
     * @method createToken
     */
    createToken: function(tt, value, startLine, startCol, options){
        var reader = this._reader;
        options = options || {};

        return {
            value:      value,
            type:       tt,
            channel:    options.channel,
            endChar:    options.endChar,
            hide:       options.hide || false,
            startLine:  startLine,
            startCol:   startCol,
            endLine:    reader.getLine(),
            endCol:     reader.getCol()
        };
    },

    //-------------------------------------------------------------------------
    // Methods to create specific tokens
    //-------------------------------------------------------------------------

    /**
     * Produces a token for any at-rule. If the at-rule is unknown, then
     * the token is for a single "@" character.
     * @param {String} first The first character for the token.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method atRuleToken
     */
    atRuleToken: function(first, startLine, startCol){
        var rule    = first,
            reader  = this._reader,
            tt      = Tokens.CHAR,
            valid   = false,
            ident,
            c;

        /*
         * First, mark where we are. There are only four @ rules,
         * so anything else is really just an invalid token.
         * Basically, if this doesn't match one of the known @
         * rules, just return '@' as an unknown token and allow
         * parsing to continue after that point.
         */
        reader.mark();

        //try to find the at-keyword
        ident = this.readName();
        rule = first + ident;
        tt = Tokens.type(rule.toLowerCase());

        //if it's not valid, use the first character only and reset the reader
        if (tt == Tokens.CHAR || tt == Tokens.UNKNOWN){
            if (rule.length > 1){
                tt = Tokens.UNKNOWN_SYM;
            } else {
                tt = Tokens.CHAR;
                rule = first;
                reader.reset();
            }
        }

        return this.createToken(tt, rule, startLine, startCol);
    },

    /**
     * Produces a character token based on the given character
     * and location in the stream. If there's a special (non-standard)
     * token name, this is used; otherwise CHAR is used.
     * @param {String} c The character for the token.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method charToken
     */
    charToken: function(c, startLine, startCol){
        var tt = Tokens.type(c);
        var opts = {};

        if (tt == -1){
            tt = Tokens.CHAR;
        } else {
            opts.endChar = Tokens[tt].endChar;
        }

        return this.createToken(tt, c, startLine, startCol, opts);
    },

    /**
     * Produces a character token based on the given character
     * and location in the stream. If there's a special (non-standard)
     * token name, this is used; otherwise CHAR is used.
     * @param {String} first The first character for the token.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method commentToken
     */
    commentToken: function(first, startLine, startCol){
        var reader  = this._reader,
            comment = this.readComment(first);

        return this.createToken(Tokens.COMMENT, comment, startLine, startCol);
    },

    /**
     * Produces a comparison token based on the given character
     * and location in the stream. The next character must be
     * read and is already known to be an equals sign.
     * @param {String} c The character for the token.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method comparisonToken
     */
    comparisonToken: function(c, startLine, startCol){
        var reader  = this._reader,
            comparison  = c + reader.read(),
            tt      = Tokens.type(comparison) || Tokens.CHAR;

        return this.createToken(tt, comparison, startLine, startCol);
    },

    /**
     * Produces a hash token based on the specified information. The
     * first character provided is the pound sign (#) and then this
     * method reads a name afterward.
     * @param {String} first The first character (#) in the hash name.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method hashToken
     */
    hashToken: function(first, startLine, startCol){
        var reader  = this._reader,
            name    = this.readName(first);

        return this.createToken(Tokens.HASH, name, startLine, startCol);
    },

    /**
     * Produces a CDO or CHAR token based on the specified information. The
     * first character is provided and the rest is read by the function to determine
     * the correct token to create.
     * @param {String} first The first character in the token.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method htmlCommentStartToken
     */
    htmlCommentStartToken: function(first, startLine, startCol){
        var reader      = this._reader,
            text        = first;

        reader.mark();
        text += reader.readCount(3);

        if (text == "<!--"){
            return this.createToken(Tokens.CDO, text, startLine, startCol);
        } else {
            reader.reset();
            return this.charToken(first, startLine, startCol);
        }
    },

    /**
     * Produces a CDC or CHAR token based on the specified information. The
     * first character is provided and the rest is read by the function to determine
     * the correct token to create.
     * @param {String} first The first character in the token.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method htmlCommentEndToken
     */
    htmlCommentEndToken: function(first, startLine, startCol){
        var reader      = this._reader,
            text        = first;

        reader.mark();
        text += reader.readCount(2);

        if (text == "-->"){
            return this.createToken(Tokens.CDC, text, startLine, startCol);
        } else {
            reader.reset();
            return this.charToken(first, startLine, startCol);
        }
    },

    /**
     * Produces an IDENT or FUNCTION token based on the specified information. The
     * first character is provided and the rest is read by the function to determine
     * the correct token to create.
     * @param {String} first The first character in the identifier.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method identOrFunctionToken
     */
    identOrFunctionToken: function(first, startLine, startCol){
        var reader  = this._reader,
            ident   = this.readName(first),
            tt      = Tokens.IDENT;

        //if there's a left paren immediately after, it's a URI or function
        if (reader.peek() == "("){
            ident += reader.read();
            if (ident.toLowerCase() == "url("){
                tt = Tokens.URI;
                ident = this.readURI(ident);

                //didn't find a valid URL or there's no closing paren
                if (ident.toLowerCase() == "url("){
                    tt = Tokens.FUNCTION;
                }
            } else {
                tt = Tokens.FUNCTION;
            }
        } else if (reader.peek() == ":"){  //might be an IE function

            //IE-specific functions always being with progid:
            if (ident.toLowerCase() == "progid"){
                ident += reader.readTo("(");
                tt = Tokens.IE_FUNCTION;
            }
        }

        return this.createToken(tt, ident, startLine, startCol);
    },

    /**
     * Produces an IMPORTANT_SYM or CHAR token based on the specified information. The
     * first character is provided and the rest is read by the function to determine
     * the correct token to create.
     * @param {String} first The first character in the token.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method importantToken
     */
    importantToken: function(first, startLine, startCol){
        var reader      = this._reader,
            important   = first,
            tt          = Tokens.CHAR,
            temp,
            c;

        reader.mark();
        c = reader.read();

        while(c){

            //there can be a comment in here
            if (c == "/"){

                //if the next character isn't a star, then this isn't a valid !important token
                if (reader.peek() != "*"){
                    break;
                } else {
                    temp = this.readComment(c);
                    if (temp === ""){    //broken!
                        break;
                    }
                }
            } else if (isWhitespace(c)){
                important += c + this.readWhitespace();
            } else if (/i/i.test(c)){
                temp = reader.readCount(8);
                if (/mportant/i.test(temp)){
                    important += c + temp;
                    tt = Tokens.IMPORTANT_SYM;

                }
                break;  //we're done
            } else {
                break;
            }

            c = reader.read();
        }

        if (tt == Tokens.CHAR){
            reader.reset();
            return this.charToken(first, startLine, startCol);
        } else {
            return this.createToken(tt, important, startLine, startCol);
        }


    },

    /**
     * Produces a NOT or CHAR token based on the specified information. The
     * first character is provided and the rest is read by the function to determine
     * the correct token to create.
     * @param {String} first The first character in the token.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method notToken
     */
    notToken: function(first, startLine, startCol){
        var reader      = this._reader,
            text        = first;

        reader.mark();
        text += reader.readCount(4);

        if (text.toLowerCase() == ":not("){
            return this.createToken(Tokens.NOT, text, startLine, startCol);
        } else {
            reader.reset();
            return this.charToken(first, startLine, startCol);
        }
    },

    /**
     * Produces a number token based on the given character
     * and location in the stream. This may return a token of
     * NUMBER, EMS, EXS, LENGTH, ANGLE, TIME, FREQ, DIMENSION,
     * or PERCENTAGE.
     * @param {String} first The first character for the token.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method numberToken
     */
    numberToken: function(first, startLine, startCol){
        var reader  = this._reader,
            value   = this.readNumber(first),
            ident,
            tt      = Tokens.NUMBER,
            c       = reader.peek();

        if (isIdentStart(c)){
            ident = this.readName(reader.read());
            value += ident;

            if (/^em$|^ex$|^px$|^gd$|^rem$|^vw$|^vh$|^vmax$|^vmin$|^ch$|^cm$|^mm$|^in$|^pt$|^pc$/i.test(ident)){
                tt = Tokens.LENGTH;
            } else if (/^deg|^rad$|^grad$/i.test(ident)){
                tt = Tokens.ANGLE;
            } else if (/^ms$|^s$/i.test(ident)){
                tt = Tokens.TIME;
            } else if (/^hz$|^khz$/i.test(ident)){
                tt = Tokens.FREQ;
            } else if (/^dpi$|^dpcm$/i.test(ident)){
                tt = Tokens.RESOLUTION;
            } else {
                tt = Tokens.DIMENSION;
            }

        } else if (c == "%"){
            value += reader.read();
            tt = Tokens.PERCENTAGE;
        }

        return this.createToken(tt, value, startLine, startCol);
    },

    /**
     * Produces a string token based on the given character
     * and location in the stream. Since strings may be indicated
     * by single or double quotes, a failure to match starting
     * and ending quotes results in an INVALID token being generated.
     * The first character in the string is passed in and then
     * the rest are read up to and including the final quotation mark.
     * @param {String} first The first character in the string.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method stringToken
     */
    stringToken: function(first, startLine, startCol){
        var delim   = first,
            string  = first,
            reader  = this._reader,
            prev    = first,
            tt      = Tokens.STRING,
            c       = reader.read();

        while(c){
            string += c;

            //if the delimiter is found with an escapement, we're done.
            if (c == delim && prev != "\\"){
                break;
            }

            //if there's a newline without an escapement, it's an invalid string
            if (isNewLine(reader.peek()) && c != "\\"){
                tt = Tokens.INVALID;
                break;
            }

            //save previous and get next
            prev = c;
            c = reader.read();
        }

        //if c is null, that means we're out of input and the string was never closed
        if (c === null){
            tt = Tokens.INVALID;
        }

        return this.createToken(tt, string, startLine, startCol);
    },

    unicodeRangeToken: function(first, startLine, startCol){
        var reader  = this._reader,
            value   = first,
            temp,
            tt      = Tokens.CHAR;

        //then it should be a unicode range
        if (reader.peek() == "+"){
            reader.mark();
            value += reader.read();
            value += this.readUnicodeRangePart(true);

            //ensure there's an actual unicode range here
            if (value.length == 2){
                reader.reset();
            } else {

                tt = Tokens.UNICODE_RANGE;

                //if there's a ? in the first part, there can't be a second part
                if (value.indexOf("?") == -1){

                    if (reader.peek() == "-"){
                        reader.mark();
                        temp = reader.read();
                        temp += this.readUnicodeRangePart(false);

                        //if there's not another value, back up and just take the first
                        if (temp.length == 1){
                            reader.reset();
                        } else {
                            value += temp;
                        }
                    }

                }
            }
        }

        return this.createToken(tt, value, startLine, startCol);
    },

    /**
     * Produces a S token based on the specified information. Since whitespace
     * may have multiple characters, this consumes all whitespace characters
     * into a single token.
     * @param {String} first The first character in the token.
     * @param {int} startLine The beginning line for the character.
     * @param {int} startCol The beginning column for the character.
     * @return {Object} A token object.
     * @method whitespaceToken
     */
    whitespaceToken: function(first, startLine, startCol){
        var reader  = this._reader,
            value   = first + this.readWhitespace();
        return this.createToken(Tokens.S, value, startLine, startCol);
    },




    //-------------------------------------------------------------------------
    // Methods to read values from the string stream
    //-------------------------------------------------------------------------

    readUnicodeRangePart: function(allowQuestionMark){
        var reader  = this._reader,
            part = "",
            c       = reader.peek();

        //first read hex digits
        while(isHexDigit(c) && part.length < 6){
            reader.read();
            part += c;
            c = reader.peek();
        }

        //then read question marks if allowed
        if (allowQuestionMark){
            while(c == "?" && part.length < 6){
                reader.read();
                part += c;
                c = reader.peek();
            }
        }

        //there can't be any other characters after this point

        return part;
    },

    readWhitespace: function(){
        var reader  = this._reader,
            whitespace = "",
            c       = reader.peek();

        while(isWhitespace(c)){
            reader.read();
            whitespace += c;
            c = reader.peek();
        }

        return whitespace;
    },
    readNumber: function(first){
        var reader  = this._reader,
            number  = first,
            hasDot  = (first == "."),
            c       = reader.peek();


        while(c){
            if (isDigit(c)){
                number += reader.read();
            } else if (c == "."){
                if (hasDot){
                    break;
                } else {
                    hasDot = true;
                    number += reader.read();
                }
            } else {
                break;
            }

            c = reader.peek();
        }

        return number;
    },
    readString: function(){
        var reader  = this._reader,
            delim   = reader.read(),
            string  = delim,
            prev    = delim,
            c       = reader.peek();

        while(c){
            c = reader.read();
            string += c;

            //if the delimiter is found with an escapement, we're done.
            if (c == delim && prev != "\\"){
                break;
            }

            //if there's a newline without an escapement, it's an invalid string
            if (isNewLine(reader.peek()) && c != "\\"){
                string = "";
                break;
            }

            //save previous and get next
            prev = c;
            c = reader.peek();
        }

        //if c is null, that means we're out of input and the string was never closed
        if (c === null){
            string = "";
        }

        return string;
    },
    readURI: function(first){
        var reader  = this._reader,
            uri     = first,
            inner   = "",
            c       = reader.peek();

        reader.mark();

        //skip whitespace before
        while(c && isWhitespace(c)){
            reader.read();
            c = reader.peek();
        }

        //it's a string
        if (c == "'" || c == "\""){
            inner = this.readString();
        } else {
            inner = this.readURL();
        }

        c = reader.peek();

        //skip whitespace after
        while(c && isWhitespace(c)){
            reader.read();
            c = reader.peek();
        }

        //if there was no inner value or the next character isn't closing paren, it's not a URI
        if (inner === "" || c != ")"){
            uri = first;
            reader.reset();
        } else {
            uri += inner + reader.read();
        }

        return uri;
    },
    readURL: function(){
        var reader  = this._reader,
            url     = "",
            c       = reader.peek();

        //TODO: Check for escape and nonascii
        while (/^[!#$%&\\*-~]$/.test(c)){
            url += reader.read();
            c = reader.peek();
        }

        return url;

    },
    readName: function(first){
        var reader  = this._reader,
            ident   = first || "",
            c       = reader.peek();

        while(true){
            if (c == "\\"){
                ident += this.readEscape(reader.read());
                c = reader.peek();
            } else if(c && isNameChar(c)){
                ident += reader.read();
                c = reader.peek();
            } else {
                break;
            }
        }

        return ident;
    },

    readEscape: function(first){
        var reader  = this._reader,
            cssEscape = first || "",
            i       = 0,
            c       = reader.peek();

        if (isHexDigit(c)){
            do {
                cssEscape += reader.read();
                c = reader.peek();
            } while(c && isHexDigit(c) && ++i < 6);
        }

        if (cssEscape.length == 3 && /\s/.test(c) ||
            cssEscape.length == 7 || cssEscape.length == 1){
                reader.read();
        } else {
            c = "";
        }

        return cssEscape + c;
    },

    readComment: function(first){
        var reader  = this._reader,
            comment = first || "",
            c       = reader.read();

        if (c == "*"){
            while(c){
                comment += c;

                //look for end of comment
                if (comment.length > 2 && c == "*" && reader.peek() == "/"){
                    comment += reader.read();
                    break;
                }

                c = reader.read();
            }

            return comment;
        } else {
            return "";
        }

    }
});

var Tokens  = [

    /*
     * The following token names are defined in CSS3 Grammar: http://www.w3.org/TR/css3-syntax/#lexical
     */

    //HTML-style comments
    { name: "CDO"},
    { name: "CDC"},

    //ignorables
    { name: "S", whitespace: true/*, channel: "ws"*/},
    { name: "COMMENT", comment: true, hide: true, channel: "comment" },

    //attribute equality
    { name: "INCLUDES", text: "~="},
    { name: "DASHMATCH", text: "|="},
    { name: "PREFIXMATCH", text: "^="},
    { name: "SUFFIXMATCH", text: "$="},
    { name: "SUBSTRINGMATCH", text: "*="},

    //identifier types
    { name: "STRING"},
    { name: "IDENT"},
    { name: "HASH"},

    //at-keywords
    { name: "IMPORT_SYM", text: "@import"},
    { name: "PAGE_SYM", text: "@page"},
    { name: "MEDIA_SYM", text: "@media"},
    { name: "FONT_FACE_SYM", text: "@font-face"},
    { name: "CHARSET_SYM", text: "@charset"},
    { name: "NAMESPACE_SYM", text: "@namespace"},
    { name: "VIEWPORT_SYM", text: ["@viewport", "@-ms-viewport"]},
    { name: "UNKNOWN_SYM" },
    //{ name: "ATKEYWORD"},

    //CSS3 animations
    { name: "KEYFRAMES_SYM", text: [ "@keyframes", "@-webkit-keyframes", "@-moz-keyframes", "@-o-keyframes" ] },

    //important symbol
    { name: "IMPORTANT_SYM"},

    //measurements
    { name: "LENGTH"},
    { name: "ANGLE"},
    { name: "TIME"},
    { name: "FREQ"},
    { name: "DIMENSION"},
    { name: "PERCENTAGE"},
    { name: "NUMBER"},

    //functions
    { name: "URI"},
    { name: "FUNCTION"},

    //Unicode ranges
    { name: "UNICODE_RANGE"},

    /*
     * The following token names are defined in CSS3 Selectors: http://www.w3.org/TR/css3-selectors/#selector-syntax
     */

    //invalid string
    { name: "INVALID"},

    //combinators
    { name: "PLUS", text: "+" },
    { name: "GREATER", text: ">"},
    { name: "COMMA", text: ","},
    { name: "TILDE", text: "~"},

    //modifier
    { name: "NOT"},

    /*
     * Defined in CSS3 Paged Media
     */
    { name: "TOPLEFTCORNER_SYM", text: "@top-left-corner"},
    { name: "TOPLEFT_SYM", text: "@top-left"},
    { name: "TOPCENTER_SYM", text: "@top-center"},
    { name: "TOPRIGHT_SYM", text: "@top-right"},
    { name: "TOPRIGHTCORNER_SYM", text: "@top-right-corner"},
    { name: "BOTTOMLEFTCORNER_SYM", text: "@bottom-left-corner"},
    { name: "BOTTOMLEFT_SYM", text: "@bottom-left"},
    { name: "BOTTOMCENTER_SYM", text: "@bottom-center"},
    { name: "BOTTOMRIGHT_SYM", text: "@bottom-right"},
    { name: "BOTTOMRIGHTCORNER_SYM", text: "@bottom-right-corner"},
    { name: "LEFTTOP_SYM", text: "@left-top"},
    { name: "LEFTMIDDLE_SYM", text: "@left-middle"},
    { name: "LEFTBOTTOM_SYM", text: "@left-bottom"},
    { name: "RIGHTTOP_SYM", text: "@right-top"},
    { name: "RIGHTMIDDLE_SYM", text: "@right-middle"},
    { name: "RIGHTBOTTOM_SYM", text: "@right-bottom"},

    /*
     * The following token names are defined in CSS3 Media Queries: http://www.w3.org/TR/css3-mediaqueries/#syntax
     */
    /*{ name: "MEDIA_ONLY", state: "media"},
    { name: "MEDIA_NOT", state: "media"},
    { name: "MEDIA_AND", state: "media"},*/
    { name: "RESOLUTION", state: "media"},

    /*
     * The following token names are not defined in any CSS specification but are used by the lexer.
     */

    //not a real token, but useful for stupid IE filters
    { name: "IE_FUNCTION" },

    //part of CSS3 grammar but not the Flex code
    { name: "CHAR" },

    //TODO: Needed?
    //Not defined as tokens, but might as well be
    {
        name: "PIPE",
        text: "|"
    },
    {
        name: "SLASH",
        text: "/"
    },
    {
        name: "MINUS",
        text: "-"
    },
    {
        name: "STAR",
        text: "*"
    },

    {
        name: "LBRACE",
        endChar: "}",
        text: "{"
    },
    {
        name: "RBRACE",
        text: "}"
    },
    {
        name: "LBRACKET",
        endChar: "]",
        text: "["
    },
    {
        name: "RBRACKET",
        text: "]"
    },
    {
        name: "EQUALS",
        text: "="
    },
    {
        name: "COLON",
        text: ":"
    },
    {
        name: "SEMICOLON",
        text: ";"
    },

    {
        name: "LPAREN",
        endChar: ")",
        text: "("
    },
    {
        name: "RPAREN",
        text: ")"
    },
    {
        name: "DOT",
        text: "."
    }
];

(function(){

    var nameMap = [],
        typeMap = {};

    Tokens.UNKNOWN = -1;
    Tokens.unshift({name:"EOF"});
    for (var i=0, len = Tokens.length; i < len; i++){
        nameMap.push(Tokens[i].name);
        Tokens[Tokens[i].name] = i;
        if (Tokens[i].text){
            if (Tokens[i].text instanceof Array){
                for (var j=0; j < Tokens[i].text.length; j++){
                    typeMap[Tokens[i].text[j]] = i;
                }
            } else {
                typeMap[Tokens[i].text] = i;
            }
        }
    }

    Tokens.name = function(tt){
        return nameMap[tt];
    };

    Tokens.type = function(c){
        return typeMap[c] || -1;
    };

})();



//This file will likely change a lot! Very experimental!
/*global Properties, ValidationTypes, ValidationError, PropertyValueIterator */
var Validation = {

    validate: function(property, value){

        //normalize name
        var name        = property.toString().toLowerCase(),
            parts       = value.parts,
            expression  = new PropertyValueIterator(value),
            spec        = Properties[name],
            part,
            valid,
            j, count,
            msg,
            types,
            last,
            literals,
            max, multi, group;

        if (!spec) {
            if (name.indexOf("-") !== 0){    //vendor prefixed are ok
                throw new ValidationError("Unknown property '" + property + "'.", property.line, property.col);
            }
        } else if (typeof spec != "number"){

            //initialization
            if (typeof spec == "string"){
                if (spec.indexOf("||") > -1) {
                    this.groupProperty(spec, expression);
                } else {
                    this.singleProperty(spec, expression, 1);
                }

            } else if (spec.multi) {
                this.multiProperty(spec.multi, expression, spec.comma, spec.max || Infinity);
            } else if (typeof spec == "function") {
                spec(expression);
            }

        }

    },

    singleProperty: function(types, expression, max, partial) {

        var result      = false,
            value       = expression.value,
            count       = 0,
            part;

        while (expression.hasNext() && count < max) {
            result = ValidationTypes.isAny(expression, types);
            if (!result) {
                break;
            }
            count++;
        }

        if (!result) {
            if (expression.hasNext() && !expression.isFirst()) {
                part = expression.peek();
                throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
            } else {
                 throw new ValidationError("Expected (" + types + ") but found '" + value + "'.", value.line, value.col);
            }
        } else if (expression.hasNext()) {
            part = expression.next();
            throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
        }

    },

    multiProperty: function (types, expression, comma, max) {

        var result      = false,
            value       = expression.value,
            count       = 0,
            sep         = false,
            part;

        while(expression.hasNext() && !result && count < max) {
            if (ValidationTypes.isAny(expression, types)) {
                count++;
                if (!expression.hasNext()) {
                    result = true;

                } else if (comma) {
                    if (expression.peek() == ",") {
                        part = expression.next();
                    } else {
                        break;
                    }
                }
            } else {
                break;

            }
        }

        if (!result) {
            if (expression.hasNext() && !expression.isFirst()) {
                part = expression.peek();
                throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
            } else {
                part = expression.previous();
                if (comma && part == ",") {
                    throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
                } else {
                    throw new ValidationError("Expected (" + types + ") but found '" + value + "'.", value.line, value.col);
                }
            }

        } else if (expression.hasNext()) {
            part = expression.next();
            throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
        }

    },

    groupProperty: function (types, expression, comma) {

        var result      = false,
            value       = expression.value,
            typeCount   = types.split("||").length,
            groups      = { count: 0 },
            partial     = false,
            name,
            part;

        while(expression.hasNext() && !result) {
            name = ValidationTypes.isAnyOfGroup(expression, types);
            if (name) {

                //no dupes
                if (groups[name]) {
                    break;
                } else {
                    groups[name] = 1;
                    groups.count++;
                    partial = true;

                    if (groups.count == typeCount || !expression.hasNext()) {
                        result = true;
                    }
                }
            } else {
                break;
            }
        }

        if (!result) {
            if (partial && expression.hasNext()) {
                    part = expression.peek();
                    throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
            } else {
                throw new ValidationError("Expected (" + types + ") but found '" + value + "'.", value.line, value.col);
            }
        } else if (expression.hasNext()) {
            part = expression.next();
            throw new ValidationError("Expected end of value but found '" + part + "'.", part.line, part.col);
        }
    }



};
/**
 * Type to use when a validation error occurs.
 * @class ValidationError
 * @namespace parserlib.util
 * @constructor
 * @param {String} message The error message.
 * @param {int} line The line at which the error occurred.
 * @param {int} col The column at which the error occurred.
 */
function ValidationError(message, line, col){

    /**
     * The column at which the error occurred.
     * @type int
     * @property col
     */
    this.col = col;

    /**
     * The line at which the error occurred.
     * @type int
     * @property line
     */
    this.line = line;

    /**
     * The text representation of the unit.
     * @type String
     * @property text
     */
    this.message = message;

}

//inherit from Error
ValidationError.prototype = new Error();
//This file will likely change a lot! Very experimental!
/*global Properties, Validation, ValidationError, PropertyValueIterator, console*/
var ValidationTypes = {

    isLiteral: function (part, literals) {
        var text = part.text.toString().toLowerCase(),
            args = literals.split(" | "),
            i, len, found = false;

        for (i=0,len=args.length; i < len && !found; i++){
            if (text == args[i].toLowerCase()){
                found = true;
            }
        }

        return found;
    },

    isSimple: function(type) {
        return !!this.simple[type];
    },

    isComplex: function(type) {
        return !!this.complex[type];
    },

    /**
     * Determines if the next part(s) of the given expression
     * are any of the given types.
     */
    isAny: function (expression, types) {
        var args = types.split(" | "),
            i, len, found = false;

        for (i=0,len=args.length; i < len && !found && expression.hasNext(); i++){
            found = this.isType(expression, args[i]);
        }

        return found;
    },

    /**
     * Determines if the next part(s) of the given expression
     * are one of a group.
     */
    isAnyOfGroup: function(expression, types) {
        var args = types.split(" || "),
            i, len, found = false;

        for (i=0,len=args.length; i < len && !found; i++){
            found = this.isType(expression, args[i]);
        }

        return found ? args[i-1] : false;
    },

    /**
     * Determines if the next part(s) of the given expression
     * are of a given type.
     */
    isType: function (expression, type) {
        var part = expression.peek(),
            result = false;

        if (type.charAt(0) != "<") {
            result = this.isLiteral(part, type);
            if (result) {
                expression.next();
            }
        } else if (this.simple[type]) {
            result = this.simple[type](part);
            if (result) {
                expression.next();
            }
        } else {
            result = this.complex[type](expression);
        }

        return result;
    },



    simple: {

        "<absolute-size>": function(part){
            return ValidationTypes.isLiteral(part, "xx-small | x-small | small | medium | large | x-large | xx-large");
        },

        "<attachment>": function(part){
            return ValidationTypes.isLiteral(part, "scroll | fixed | local");
        },

        "<attr>": function(part){
            return part.type == "function" && part.name == "attr";
        },

        "<bg-image>": function(part){
            return this["<image>"](part) || this["<gradient>"](part) || part == "none" || part == "inherit";
        },

        "<gradient>": function(part) {
            return part.type == "function" && /^(?:\-(?:ms|moz|o|webkit)\-)?(?:repeating\-)?(?:radial\-|linear\-)?gradient/i.test(part);
        },

        "<box>": function(part){
            return ValidationTypes.isLiteral(part, "padding-box | border-box | content-box");
        },

        "<content>": function(part){
            return part.type == "function" && part.name == "content";
        },

        "<relative-size>": function(part){
            return ValidationTypes.isLiteral(part, "smaller | larger");
        },

        //any identifier
        "<ident>": function(part){
            return part.type == "identifier";
        },

        "<length>": function(part){
            if (part.type == "function" && /^(?:\-(?:ms|moz|o|webkit)\-)?calc/i.test(part)){
                return true;
            }else{
                return part.type == "length" || part.type == "number" || part.type == "integer" || part == "0";
            }
        },

        "<color>": function(part){
            return part.type == "color" || part == "transparent";
        },

        "<number>": function(part){
            return part.type == "number" || this["<integer>"](part);
        },

        "<integer>": function(part){
            return part.type == "integer";
        },

        "<line>": function(part){
            return part.type == "integer";
        },

        "<angle>": function(part){
            return part.type == "angle";
        },

        "<uri>": function(part){
            return part.type == "uri";
        },

        "<image>": function(part){
            return this["<uri>"](part);
        },

        "<percentage>": function(part){
            return part.type == "percentage" || part == "0";
        },

        "<border-width>": function(part){
            return this["<length>"](part) || ValidationTypes.isLiteral(part, "thin | medium | thick");
        },

        "<border-style>": function(part){
            return ValidationTypes.isLiteral(part, "none | hidden | dotted | dashed | solid | double | groove | ridge | inset | outset");
        },

        "<content-sizing>": function(part){ // http://www.w3.org/TR/css3-sizing/#width-height-keywords
            return ValidationTypes.isLiteral(part, "fill-available | -moz-available | -webkit-fill-available | max-content | -moz-max-content | -webkit-max-content | min-content | -moz-min-content | -webkit-min-content | fit-content | -moz-fit-content | -webkit-fit-content");
        },

        "<margin-width>": function(part){
            return this["<length>"](part) || this["<percentage>"](part) || ValidationTypes.isLiteral(part, "auto");
        },

        "<padding-width>": function(part){
            return this["<length>"](part) || this["<percentage>"](part);
        },

        "<shape>": function(part){
            return part.type == "function" && (part.name == "rect" || part.name == "inset-rect");
        },

        "<time>": function(part) {
            return part.type == "time";
        },

        "<flex-grow>": function(part){
            return this["<number>"](part);
        },

        "<flex-shrink>": function(part){
            return this["<number>"](part);
        },

        "<width>": function(part){
            return this["<margin-width>"](part);
        },

        "<flex-basis>": function(part){
            return this["<width>"](part);
        },

        "<flex-direction>": function(part){
            return ValidationTypes.isLiteral(part, "row | row-reverse | column | column-reverse");
        },

        "<flex-wrap>": function(part){
            return ValidationTypes.isLiteral(part, "nowrap | wrap | wrap-reverse");
        }
    },

    complex: {

        "<bg-position>": function(expression){
            var types   = this,
                result  = false,
                numeric = "<percentage> | <length>",
                xDir    = "left | right",
                yDir    = "top | bottom",
                count = 0,
                hasNext = function() {
                    return expression.hasNext() && expression.peek() != ",";
                };

            while (expression.peek(count) && expression.peek(count) != ",") {
                count++;
            }

/*
<position> = [
  [ left | center | right | top | bottom | <percentage> | <length> ]
|
  [ left | center | right | <percentage> | <length> ]
  [ top | center | bottom | <percentage> | <length> ]
|
  [ center | [ left | right ] [ <percentage> | <length> ]? ] &&
  [ center | [ top | bottom ] [ <percentage> | <length> ]? ]
]
*/

            if (count < 3) {
                if (ValidationTypes.isAny(expression, xDir + " | center | " + numeric)) {
                        result = true;
                        ValidationTypes.isAny(expression, yDir + " | center | " + numeric);
                } else if (ValidationTypes.isAny(expression, yDir)) {
                        result = true;
                        ValidationTypes.isAny(expression, xDir + " | center");
                }
            } else {
                if (ValidationTypes.isAny(expression, xDir)) {
                    if (ValidationTypes.isAny(expression, yDir)) {
                        result = true;
                        ValidationTypes.isAny(expression, numeric);
                    } else if (ValidationTypes.isAny(expression, numeric)) {
                        if (ValidationTypes.isAny(expression, yDir)) {
                            result = true;
                            ValidationTypes.isAny(expression, numeric);
                        } else if (ValidationTypes.isAny(expression, "center")) {
                            result = true;
                        }
                    }
                } else if (ValidationTypes.isAny(expression, yDir)) {
                    if (ValidationTypes.isAny(expression, xDir)) {
                        result = true;
                        ValidationTypes.isAny(expression, numeric);
                    } else if (ValidationTypes.isAny(expression, numeric)) {
                        if (ValidationTypes.isAny(expression, xDir)) {
                                result = true;
                                ValidationTypes.isAny(expression, numeric);
                        } else if (ValidationTypes.isAny(expression, "center")) {
                            result = true;
                        }
                    }
                } else if (ValidationTypes.isAny(expression, "center")) {
                    if (ValidationTypes.isAny(expression, xDir + " | " + yDir)) {
                        result = true;
                        ValidationTypes.isAny(expression, numeric);
                    }
                }
            }

            return result;
        },

        "<bg-size>": function(expression){
            //<bg-size> = [ <length> | <percentage> | auto ]{1,2} | cover | contain
            var types   = this,
                result  = false,
                numeric = "<percentage> | <length> | auto",
                part,
                i, len;

            if (ValidationTypes.isAny(expression, "cover | contain")) {
                result = true;
            } else if (ValidationTypes.isAny(expression, numeric)) {
                result = true;
                ValidationTypes.isAny(expression, numeric);
            }

            return result;
        },

        "<repeat-style>": function(expression){
            //repeat-x | repeat-y | [repeat | space | round | no-repeat]{1,2}
            var result  = false,
                values  = "repeat | space | round | no-repeat",
                part;

            if (expression.hasNext()){
                part = expression.next();

                if (ValidationTypes.isLiteral(part, "repeat-x | repeat-y")) {
                    result = true;
                } else if (ValidationTypes.isLiteral(part, values)) {
                    result = true;

                    if (expression.hasNext() && ValidationTypes.isLiteral(expression.peek(), values)) {
                        expression.next();
                    }
                }
            }

            return result;

        },

        "<shadow>": function(expression) {
            //inset? && [ <length>{2,4} && <color>? ]
            var result  = false,
                count   = 0,
                inset   = false,
                color   = false,
                part;

            if (expression.hasNext()) {

                if (ValidationTypes.isAny(expression, "inset")){
                    inset = true;
                }

                if (ValidationTypes.isAny(expression, "<color>")) {
                    color = true;
                }

                while (ValidationTypes.isAny(expression, "<length>") && count < 4) {
                    count++;
                }


                if (expression.hasNext()) {
                    if (!color) {
                        ValidationTypes.isAny(expression, "<color>");
                    }

                    if (!inset) {
                        ValidationTypes.isAny(expression, "inset");
                    }

                }

                result = (count >= 2 && count <= 4);

            }

            return result;
        },

        "<x-one-radius>": function(expression) {
            //[ <length> | <percentage> ] [ <length> | <percentage> ]?
            var result  = false,
                simple = "<length> | <percentage> | inherit";

            if (ValidationTypes.isAny(expression, simple)){
                result = true;
                ValidationTypes.isAny(expression, simple);
            }

            return result;
        },

        "<flex>": function(expression) {
            // http://www.w3.org/TR/2014/WD-css-flexbox-1-20140325/#flex-property
            // none | [ <flex-grow> <flex-shrink>? || <flex-basis> ]
            // Valid syntaxes, according to https://developer.mozilla.org/en-US/docs/Web/CSS/flex#Syntax
            // * none
            // * <flex-grow>
            // * <flex-basis>
            // * <flex-grow> <flex-basis>
            // * <flex-grow> <flex-shrink>
            // * <flex-grow> <flex-shrink> <flex-basis>
            // * inherit
            var part,
                result = false;
            if (ValidationTypes.isAny(expression, "none | inherit")) {
                result = true;
            } else {
                if (ValidationTypes.isType(expression, "<flex-grow>")) {
                    if (expression.peek()) {
                        if (ValidationTypes.isType(expression, "<flex-shrink>")) {
                            if (expression.peek()) {
                                result = ValidationTypes.isType(expression, "<flex-basis>");
                            } else {
                                result = true;
                            }
                        } else if (ValidationTypes.isType(expression, "<flex-basis>")) {
                            result = expression.peek() === null;
                        }
                    } else {
                        result = true;
                    }
                } else if (ValidationTypes.isType(expression, "<flex-basis>")) {
                    result = true;
                }
            }

            if (!result) {
                // Generate a more verbose error than "Expected <flex>..."
                part = expression.peek();
                throw new ValidationError("Expected (none | [ <flex-grow> <flex-shrink>? || <flex-basis> ]) but found '" + expression.value.text + "'.", part.line, part.col);
            }

            return result;
        }
    }
};

parserlib.css = {
Colors              :Colors,
Combinator          :Combinator,
Parser              :Parser,
PropertyName        :PropertyName,
PropertyValue       :PropertyValue,
PropertyValuePart   :PropertyValuePart,
MediaFeature        :MediaFeature,
MediaQuery          :MediaQuery,
Selector            :Selector,
SelectorPart        :SelectorPart,
SelectorSubPart     :SelectorSubPart,
Specificity         :Specificity,
TokenStream         :TokenStream,
Tokens              :Tokens,
ValidationError     :ValidationError
};
})();

(function(){
for(var prop in parserlib){
exports[prop] = parserlib[prop];
}
})();


================================================
FILE: gulp/util/destCSS.js
================================================
var mergeStream = require('merge-stream');
var argv = require('minimist')(process.argv.slice(2));
var gulp = require('gulp');

var config = require('../../app/config');
var { buildCSS } = require('../util/buildCSS');

exports.destCSS = function destCSS() {
    var buildRules = [];

    var skins = config.skins;
    var packages = Object.keys(config.packages);
    var browsers = ['', 'ie8'];

    if (argv.pkg || argv.skin) {
        // Custom build
        buildRules = browsers.map(function(browser) {
            return {
                suffix: browser === 'ie8' ? 'ie8' : null,
                pkg: argv.pkg || 'full',
                skin: argv.skin || config.appConfig.defaultSkin,
                ie8: browser === 'ie8',
                isTest: global.isTestBuild
            };
        });
    } else {
        packages.forEach(function(pkg) {
            skins.forEach(function(skin) {
                browsers.forEach(function(browser) {
                    buildRules.push({
                        suffix: [pkg, skin, browser].join('.').replace(/\.$/, ''),
                        pkg: pkg,
                        skin: skin,
                        ie8: browser === 'ie8',
                        isTest: global.isTestBuild
                    });
                });
            });
        });
    }

    return mergeStream(buildRules.map(function(buildRule) {
        return buildCSS(buildRule).pipe(gulp.dest('dist/css/'));
    }));
};


================================================
FILE: gulp/util/error.js
================================================
var plumber = require('gulp-plumber');
var notify = require('gulp-notify');

function errorNotify(err) {
    var args = Array.prototype.slice.call(arguments);

    // Send error to notification center with gulp-notify
    notify.onError({
        title: 'Build Error',
        message: '<%= error.message %>'
    }, function() {
        console.error('Build failure');

        if (err.stack) {
            console.error(err.stack);
        }

        process.exit(1);
    }).apply(this, args);
}

function errorHandle() {
    return plumber({
        errorHandler: errorNotify
    });
}

module.exports = {
    notify: errorNotify,
    handle: errorHandle
};


================================================
FILE: gulp/util/gendoc.js
================================================
var fs = require('fs'),
    marked = require('marked'),
    mkdirp = require('mkdirp');

function walkItem(menu, callback) { // (Object, Function)
    for (var item in menu) {
        var content = menu[item].content;
        if (content) {
            if (content.ru && content.ru._src) {
                callback(menu[item].content.ru._src);
            }
            if (content.en && content.en._src) {
                callback(menu[item].content.en._src);
            }
        }
        if (menu[item].children) {
            walkItem(menu[item].children, callback);
        }
    }
}

function getMdFileNames() { // (Object) -> Object
    var menu = require('../../src/menu.json'),
        result = [];
    walkItem(menu, function(filepath) {
        result.push(filepath);
    });
    return result;
}

function getMdFilesData(list, subdir) { // (Array, String) -> Array
    var sorce = [],
        dir = subdir || '',
        listLeng = list.length;

    for (var i = 0; i < listLeng; i++) {
        var fullFilePath = dir + list[i];
        if (fs.existsSync(fullFilePath)) {
            var md = {};
            md.path = list[i];
            md.content = fs.readFileSync(fullFilePath);
            sorce.push(md);
        }

    }
    return sorce;
}

function copyConfigFile(filepath, destpath) { // (String, String)
    var configName = filepath.match(/[^/]+$/)[0];

    mkdirp(destpath, function() {
        fs.writeFileSync(destpath + '/' + configName, fs.readFileSync(filepath));
    });
}

function writeFile(dir, htmlFileName, html) {
    mkdirp(dir, function() {
        fs.writeFileSync(dir + '/' + htmlFileName, html);
    });
}

// Usage: generateDocumentation('menu.json', './src', './doc')
function generateDocumentation(config, rootPath, destPath) { // (Object, String, String)
    var mdFileNames = getMdFileNames(),
        mdData = getMdFilesData(mdFileNames, rootPath);

    for (var i = 0, leng = mdData.length; i < leng; i++) {
        (function(i) {
            var mdFilePath = mdData[i].path,
                htmlFileName = mdFilePath.match(/([\w_-]+)\.md$/i)[1] + '.html',
                pluginDirName = mdFilePath.match(/\/?(.*)\/[.\w_-]+$/)[1],
                renderer = new marked.Renderer(),
                tocHtml = generateTableOfContents(marked.lexer(mdData[i].content.toString())),
                headerRepeats = {},
                dir = destPath + '/' + pluginDirName + '/',
                html;

            renderer.listitem = function(text) {
                return '<li><div class="restore-color">' + text + '</div></li>';
            };

            renderer.heading = function(text, level) {
                if (typeof headerRepeats[text] === 'undefined') {
                    headerRepeats[text] = 0;
                } else {
                    headerRepeats[text]++;
                }
                return '<h' + level + ' id="' + getHeaderId(text, headerRepeats[text]) + '">' + text + '</h' + level + '>';
            };

            html = marked(mdData[i].content.toString(), {
                renderer: renderer
            });

            html = html.replace('<ul>', '<ul class="list-v-disc">');
            html = html.replace(/\{toc}/g, tocHtml);

            writeFile(dir, htmlFileName, html);
        })(i);
    }

    copyConfigFile(config, destPath);
}

function generateTableOfContents(tokens) { // (Array) -> String
    // generate ToC for H2, H3, ...
    var prevDepth = 2,
        startH = prevDepth,
        tocHtml = '',
        headers = [],
        headerRepeats = {};

    // extract headers from all tokens
    tokens.forEach(function(token) {
        if (token.type === 'heading' && token.depth > startH) headers.push(token);
    });

    // assign number for each header
    headers.forEach(function(header) {
        if (typeof headerRepeats[header.text] === 'undefined') {
            headerRepeats[header.text] = 0;
        }
        else {
            headerRepeats[header.text]++;
        }
        header.num = headerRepeats[header.text];
    });

    // generate html
    for (var j = 0; j < headers.length; j++) {
        var header = headers[j],
            nextHeader = headers[j+1];

        header.text = '<a href="#' + getHeaderId(header.text, header.num) + '">' + header.text + '</a>';

        if (header.depth > prevDepth) { // enter to the list
            tocHtml += prevDepth === startH ? '<ul class="page-contents">' : '<ul>';
            tocHtml += '<li>' + header.text;
        }
        else if (header.depth === prevDepth) { // move by list
            tocHtml += '<li>' + header.text;
        }
        else if (header.depth < prevDepth) {
            tocHtml += '</ul></li>';
            tocHtml += '<li>' + header.text;
        }

        // if hasn't childs
        if (typeof nextHeader === 'undefined' || nextHeader.depth <= header.depth) {
            tocHtml += '</li>';
        }
        // if last header
        if (typeof nextHeader === 'undefined') {
            tocHtml += '</ul>';
        }

        prevDepth = header.depth;
    }
    tocHtml = '<dl class="api-incut">' + tocHtml + '</dl>';

    return tocHtml;
}

function getHeaderId(text, num) { // (String, Number) -> String
    var id = text.toLowerCase().replace(' ', '-');
    id = id.replace('.', '');
    id = num > 0 ? id + '-' + num : id;
    return id;
}

exports.generateDocumentation = generateDocumentation;


================================================
FILE: gulp/util/projectList.js
================================================
var projectList;

module.exports = {
    set: function(val) {
        projectList = val;
    },
    get: function() {
        return projectList;
    }
};


================================================
FILE: gulp/util/stat.js
================================================
var prettyBytes = require('pretty-bytes');
var path = require('path');

var stat = {};

function save(file, cb) {
    var name = path.basename(file.path.split('/').pop());

    stat[name] = prettyBytes(file.contents.length);

    cb(null, file);
}

function get() {
    return stat;
}

module.exports = {
    save: save,
    get: get
};


================================================
FILE: gulp/util/templateStream.js
================================================
var path = require('path');
var gulp = require('gulp');
var dust = require('gulp-dust');

var config = require('../../app/config.js');
var deps = require('../deps')(config);

module.exports = function(pkg) {
    var templateList = deps.getModulesList(pkg)
        .map(function(moduleName) {
            return 'src/' + moduleName + '/templates/*.dust';
        });

    return gulp.src(templateList).pipe(dust({
        name: function(file) {
            var moduleName = path.basename(path.dirname(path.dirname(file.path)));
            var templateName = path.basename(file.relative, '.dust');

            return moduleName + '/' + templateName;
        }
    }));
};


================================================
FILE: gulpfile.js
================================================
const { build } = require('./gulp/tasks/build');
const { lint } = require('./gulp/tasks/lint');
const { test } = require('./gulp/tasks/test');
const { dev } = require('./gulp/tasks/dev');
const { clean } = require('./gulp/tasks/clean');

module.exports = {
    build,
    lint,
    test,
    dev,
    clean,
};


================================================
FILE: package.json
================================================
{
  "name": "2gis-maps",
  "version": "4.0.12",
  "description": "Interactive 2GIS maps API, based on Leaflet",
  "license": "SEE LICENSE IN FILE",
  "keywords": [
    "2gis",
    "map",
    "api"
  ],
  "scripts": {
    "test": "gulp lint && gulp test",
    "start": "npm run build && node app",
    "build": "gulp build --release",
    "dev": "gulp dev",
    "lint": "gulp lint",
    "pub": "gulp clean && gulp build --npm --release && npm publish"
  },
  "repository": {
    "type": "git",
    "url": "git@github.com:2gis/mapsapi.git"
  },
  "main": "dist/js/script.full.js",
  "dependencies": {
    "cors": "^2.7.1",
    "dotenv": "^8.6.0",
    "dustjs-helpers": "1.7.3",
    "dustjs-linkedin": "3.0.1",
    "express": "^4.13.4",
    "html5shiv": "^3.7.3",
    "leaflet": "1.0.1",
    "lodash": "4.17.21"
  },
  "devDependencies": {
    "browserify": "^13.0.1",
    "browserify-css": "^0.9.1",
    "coveralls": "^2.11.9",
    "del": "^5.1.0",
    "event-stream": "^3.3.2",
    "fancy-log": "^1.3.2",
    "glob": "^7.0.3",
    "gulp": "^4.0.2",
    "gulp-autoprefixer": "^3.1.0",
    "gulp-cached": "^1.1.0",
    "gulp-clean-css": "^2.0.4",
    "gulp-concat": "^2.6.0",
    "gulp-derequire": "^2.1.0",
    "gulp-dust": "^3.0.0",
    "gulp-eslint": "^6.0.0",
    "gulp-flatten": "0.2.0",
    "gulp-footer": "^1.0.5",
    "gulp-header": "1.8.2",
    "gulp-if": "^2.0.0",
    "gulp-imagemin": "^2.4.0",
    "gulp-insert": "^0.5.0",
    "gulp-less": "^3.0.5",
    "gulp-notify": "^3.2.0",
    "gulp-plumber": "^1.2.1",
    "gulp-remember": "^0.3.0",
    "gulp-rename": "^1.2.2",
    "gulp-replace": "^0.5.4",
    "gulp-sourcemaps": "^2.6.5",
    "gulp-uglify": "^1.5.4",
    "gulp.spritesmith": "^6.2.1",
    "happen": "~0.3.0",
    "image-size": "0.5.0",
    "karma": "^0.13.22",
    "karma-chrome-launcher": "^0.2.0",
    "karma-coverage": "^0.5.5",
    "karma-expect": "^1.1.0",
    "karma-firefox-launcher": "^0.1.0",
    "karma-mocha": "^0.2.0",
    "karma-mocha-reporter": "^2.0.0",
    "karma-opera-launcher": "^0.3.0",
    "karma-phantomjs-launcher": "^1.0.0",
    "karma-sinon": "^1.0.4",
    "less": "^2.6.1",
    "map-stream": "0.1.0",
    "marked": "0.3.5",
    "merge-stream": "^2.0.0",
    "minimist": "^1.2.0",
    "mkdirp": "0.5.1",
    "mocha": "^2.4.5",
    "mock-geolocation": "^1.0.11",
    "optimist": "^0.6.1",
    "phantomjs-prebuilt": "2.1.11",
    "pixelsmith": "^2.1.0",
    "plugin-error": "^1.0.1",
    "pretty-bytes": "^4.0.2",
    "prosthetic-hand": "^1.3.0",
    "request": "^2.70.0",
    "sinon": "^1.17.3",
    "streamqueue": "^1.1.1",
    "vinyl-buffer": "^1.0.0",
    "vinyl-source-stream": "^2.0.0"
  }
}


================================================
FILE: src/DGAjax/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <title>DGAjax & DGPromise demo</title>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>
</head>
<body>

<div id="map" style="width: 100%; height: 400px; border: 1px solid #ccc;"></div>

<script type="text/javascript">

    // Avoid `console` errors in browsers that lack a console.
    (function() {
        var method;
        var noop = function () {};
        var methods = [
            'assert', 'clear', 'count', 'debug', 'dir', 'dirxml', 'error',
            'exception', 'group', 'groupCollapsed', 'groupEnd', 'info', 'log',
            'markTimeline', 'profile', 'profileEnd', 'table', 'time', 'timeEnd',
            'timeStamp', 'trace', 'warn'
        ];
        var length = methods.length;
        var console = (window.console = window.console || {});

        while (length--) {
            method = methods[length];

            if (!console[method]) {
                console[method] = noop;
            }
        }
    }());

    DG.then(function () {

        var map = new DG.Map('map', {
            center: new DG.LatLng(54.980206086231, 82.898068362003),
            zoom: 17,
            geoclicker: true,
            key: DG.config.key || 'Your API access key'
        });

        function test_get(){
            console.group('Test XHR GET');
            return DG.ajax('http://catalog.api.2gis.ru/2.0/search', {
                type: 'get',
                data: {
                    key: 'ruregt3044',
                    type: 'filial',
                    house: 141373143572328,
                    page: 1
                },
                success: function(data) {
                    console.log('success', data);
                },
                error: function(error) {
                    console.warn('error', error);
                }
            }).then(
                function(data) {
                    console.log('promise resolve', data);
                    console.groupEnd();
                },
                function(error) {
                    console.warn('promise reject', error);
                    console.groupEnd();
                }
            );
        }

        function test_post(){
            console.group('Test XHR POST');
            return DG.ajax('http://catalog.api.2gis.ru/2.0/search', {
                type: 'post',
                data: {
                    key: 'ruregt3044',
                    type: 'filial',
                    house: 141373143572328,
                    page: 1
                },
                success: function(data) {
                    console.log('success', data);
                },
                error: function(error) {
                    console.warn('error', error);
                }
            }).then(
                function(data) {
                    console.log('promise resolve', data);
                    console.groupEnd();
                },
                function(error) {
                    console.warn('promise reject', error);
                    console.groupEnd();
                }
            );
        }

        DG.DomEvent.addListener( DG.DomUtil.get('sendRequest'), 'click', function(){
            test_get().then(test_post).then(function(){
                console.info('Everything seems to be ok!');
            });
        });

    });
</script>
<button id="sendRequest">Сделать запрос</button>
</body>
</html>


================================================
FILE: src/DGAjax/src/DGAjax.js
================================================
DG.ajax = (function() {

    var win = window,
        doc = document,

        rurl = /^([\w.+-]+:)?(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,
        twoHundo = /^20\d$/,

        // Document location
        ajaxLocParts,
        ajaxLocation,

        byTag = 'getElementsByTagName',
        readyState = 'readyState',
        contentType = 'Content-Type',
        requestedWith = 'X-Requested-With',
        head = doc[byTag]('head')[0],
        uniqid = 0,
        callbackPrefix = 'l_dg_ajax_callback_' + (+new Date()),
        lastValue, // data stored by the most recent JSONP callback
        xmlHttpRequest = 'XMLHttpRequest',
        xDomainRequest = 'XDomainRequest', // IE 8 and 9 only
        noop = function() {},
        defaultHeaders = {
            contentType: 'application/x-www-form-urlencoded',
            requestedWith: xmlHttpRequest,
            accept: {
                '*':  'text/javascript, text/html, application/xml, text/xml, */*',
                xml:  'application/xml, text/xml',
                html: 'text/html',
                text: 'text/plain',
                json: 'application/json, text/javascript',
                js:   'application/javascript, text/javascript'
            }
        },
        /*global XDomainRequest:false */
        xhr = function(o) {
            // is it x-domain
            if (o.crossDomain === true) {
                var xhr = win[xmlHttpRequest] ? new XMLHttpRequest() : null;
                if (xhr && 'withCredentials' in xhr) {
                    return xhr;
                } else if (win[xDomainRequest]) {
                    return new XDomainRequest();
                } else {
                    throw new Error('Browser does not support cross-origin requests');
                }
            } else {
                return new XMLHttpRequest();
            }
        },

        globalSetupOptions = {
            dataFilter: function(data) {
                return data;
            }
        };

    // IE may throw an exception when accessing
    // a field from window.location if document.domain has been set
    try {
        ajaxLocation = location.href;
    } catch (e) {
        // Use the href attribute of an A element
        // since IE will modify it given document.location
        ajaxLocation = document.createElement('a');
        ajaxLocation.href = '';
        ajaxLocation = ajaxLocation.href;
    }

    // Segment location into parts
    ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase()) || [];

    function handleReadyState(r, success, error) {
        return function() {
            // use _aborted to mitigate against IE err c00c023f
            // (can't read props on aborted request objects)
            if (r._aborted) {
                return error(r.request);
            }
            if (r.request && r.request[readyState] === 4) {
                r.request.onreadystatechange = noop;
                if (twoHundo.test(r.request.status)) {
                    success(r.request);
                } else {
                    error(r.request);
                }
            }
        };
    }

    function setHeaders(http, o) {
        var headers = o.headers || {},
            h;

        headers.Accept = headers.Accept || defaultHeaders.accept[o.dataType] || defaultHeaders.accept['*'];

        // breaks cross-origin requests with legacy browsers
        if (!o.crossDomain && !headers[requestedWith]) {
            headers[requestedWith] = defaultHeaders.requestedWith;
        }
        if (!headers[contentType]) {
            headers[contentType] = o.contentType || defaultHeaders.contentType;
        }
        for (h in headers) {
            if (headers.hasOwnProperty(h) && 'setRequestHeader' in http) {
                http.setRequestHeader(h, headers[h]);
            }
        }
    }

    function setCredentials(http, o) {
        if (typeof o.withCredentials !== 'undefined' && typeof http.withCredentials !== 'undefined') {
            http.withCredentials = !!o.withCredentials;
        }
    }

    function generalCallback(data) {
        lastValue = data;
    }

    function urlappend(url, s) {
        return url + (/\?/.test(url) ? '&' : '?') + s;
    }

    function handleJsonp(o, fn, err, url) {
        var reqId = uniqid++,
            cbkey = o.jsonpCallback || 'callback', // the 'callback' key
            cbval = o.jsonpCallbackName || callbackPrefix,
            cbreg = new RegExp('((^|\\?|&)' + cbkey + ')=([^&]+)'),
            match = url.match(cbreg),
            script = doc.createElement('script'),
            loaded = 0,
            isIE10 = navigator.userAgent.indexOf('MSIE 10.0') !== -1;

        if (match) {
            if (match[3] === '?') {
                url = url.replace(cbreg, '$1=' + cbval); // wildcard callback func name
            } else {
                cbval = match[3]; // provided callback func name
            }
        } else {
            url = urlappend(url, cbkey + '=' + cbval); // no callback details, add 'em
        }

        win[cbval] = generalCallback;

        script.type = 'text/javascript';
        script.src = url;
        script.async = true;
        if (typeof script.onreadystatechange !== 'undefined' && !isIE10) {
            // need this for IE due to out-of-order onreadystatechange(), binding script
            // execution to an event listener gives us control over when the script
            // is executed. See http://jaubourg.net/2010/07/loading-script-as-onclick-handler-of.html
            //
            // if this hack is used in IE10 jsonp callback are never called
            script.event = 'onclick';
            script.htmlFor = script.id = '_request_' + reqId;
        }

        script.onerror = function() {
            script.onerror = script.onload = script.onreadystatechange = null;
            err({}, 'Request unknown error', {});
            lastValue = undefined;
            head.removeChild(script);
            loaded = 1;
        };
        script.onload = script.onreadystatechange = function() {
            if ((script[readyState] && script[readyState] !== 'complete' && script[readyState] !== 'loaded') || loaded) {
                return false;
            }
            script.onerror = script.onload = script.onreadystatechange = null;
            if (script.onclick) {
                script.onclick();
            }
            // Call the user callback with the last value stored and clean up values and scripts.
            fn(lastValue);
            lastValue = undefined;
            head.removeChild(script);
            loaded = 1;
        };

        // Add the script to the DOM head
        head.appendChild(script);

        // Enable JSONP timeout
        return {
            abort: function() {
                script.onerror = script.onload = script.onreadystatechange = null;
                err({}, 'Request is aborted: timeout', {});
                lastValue = undefined;
                head.removeChild(script);
                loaded = 1;
            }
        };
    }

    function getRequest(fn, err) {
        var o = this.options,
            method = (o.type || 'GET').toUpperCase(),
            url = typeof o === 'string' ? o : o.url,
            // convert non-string objects to query-string form unless o.processData is false
            data = (o.processData !== false && o.data && typeof o.data !== 'string') ? Ajax.toQueryString(o.data) : (o.data || null),
            http,
            sendWait = false;

        // if we're working on a GET request and we have data then we should append
        // query string to end of URL and not post data
        if ((o.type === 'jsonp' || method === 'GET') && data) {
            url = urlappend(url, data);
            data = null;
        }

        if (o.type === 'jsonp') {
            return handleJsonp(o, fn, err, url);
        }

        http = xhr(o);
        http.open(method, url, o.async !== false);

        setHeaders(http, o);
        setCredentials(http, o);

        if (win[xDomainRequest] && http instanceof win[xDomainRequest]) {
            http.onload = fn;
            http.onprogress = function() {};
            http.ontimeout = function() {};
            http.onerror = err;
            sendWait = true;
        } else {
            http.onreadystatechange = handleReadyState(this, fn, err);
        }
        if (sendWait) {
            setTimeout(function() {
                http.send(data);
            }, 200);
        } else {
            http.send(data);
        }
        return http;
    }

    function buildParams(prefix, obj, traditional, add) {
        var name, i, v,
            rbracket = /\[\]$/;

        if (DG.Util.isArray(obj)) {
        // Serialize array item.
            for (i = 0; obj && i < obj.length; i++) {
                v = obj[i];
                if (traditional || rbracket.test(prefix)) {
                    // Treat each array item as a scalar.
                    add(prefix, v);
                } else {
                    buildParams(prefix + '[' + (typeof v === 'object' ? i : '') + ']', v, traditional, add);
                }
            }
        } else if (obj && obj.toString() === '[object Object]') {
            // Serialize object item.
            for (name in obj) {
                if (obj.hasOwnProperty(name)) {
                    buildParams(prefix + '[' + name + ']', obj[name], traditional, add);
                }
            }
        } else {
            // Serialize scalar item.
            add(prefix, obj);
        }
    }

    function setType(url) {
        var m = url.match(/\.(json|jsonp|html|xml)(\?|$)/);
        return m ? m[1] : 'js';
    }

    function isCrossDomain(url) {
        var parts = rurl.exec(url.toLowerCase());
        return !!(parts &&
                (parts[1] !== ajaxLocParts[1] || parts[2] !== ajaxLocParts[2] ||
                    (parts[3] || (parts[1] === 'http:' ? '80' : '443')) !==
                        (ajaxLocParts[3] || (ajaxLocParts[1] === 'http:' ? '80' : '443')))
        );
    }

    function doRequest(o) {

        if (!('crossDomain' in o)) {
            o.crossDomain = isCrossDomain(o.url);
        }

        var self = {};
        self.promise = new Promise(function(resolve, reject) {
            self.abort = function() {
                self._aborted = true;
                reject('aborted');
            };

            self.url = o.url;
            self.timeout = null;
            self.options = o;

            self._aborted = false;
            self._erred = false;
            self._responseArgs = {};

            var type = o.type === 'jsonp' ? o.type : (o.dataType || setType(self.url));

            if (o.timeout) {
                self.timeout = setTimeout(function() {
                    self.abort();
                }, o.timeout);
            }

            function complete(resp) {
                if (o.timeout) {
                    clearTimeout(self.timeout);
                }
                self.timeout = null;
                if (self._erred) {
                    reject(resp);
                } else {
                    resolve(resp);
                }
            }

            function success(resp) {
                resp = (type !== 'jsonp') ? self.request : resp;
                // use global data filter on response text
                var filteredResponse = globalSetupOptions.dataFilter(resp.responseText, type),
                    r = filteredResponse;

                try {
                    resp.responseText = r;
                } catch (e) {
                    // can't assign this in IE<=8, just ignore
                }
                /* eslint-disable no-eval */
                if (r) {
                    switch (type) {
                        case 'json':
                            try {
                                resp = win.JSON.parse(r);
                            } catch (err) {
                                return error(resp, 'Could not parse JSON in response', err);
                            }
                            break;
                        case 'js':
                            resp = eval('(' + r + ')');
                            break;
                        case 'html':
                            resp = r;
                            break;
                        case 'xml':
                            resp = resp.responseXML && resp.responseXML.parseError && resp.responseXML.parseError.errorCode && resp.responseXML.parseError.reason ? null : resp.responseXML;
                            break;
                    }
                }
                /* eslint-enable no-eval */
                self._responseArgs.resp = resp;
                complete(resp);
            }

            function error(resp, msg, t) {
                resp = self.request;
                self._responseArgs.resp = resp;
                self._responseArgs.msg = msg;
                self._responseArgs.t = t;
                self._erred = true;
                complete(resp);
            }

            self.request = getRequest.call(self, success, error);
        });

        return self;
    }

    function Ajax(url, options) {

        if (Object.prototype.toString.call(url) === '[object Object]') {
            options = url;
            url = undefined;
        }
        options = options || {};
        options.url = url || options.url;

        var requestPromise = doRequest(options),
            resultPromise = requestPromise.promise;

        if (options.success || options.error || options.complete) {
            resultPromise.then(options.success, options.error);
        }

        resultPromise.abort = requestPromise.abort;

        return resultPromise;
    }

    Ajax.setup = function(options) {
        options = options || {};
        for (var k in options) {
            if (options.hasOwnProperty(k)) {
                globalSetupOptions[k] = options[k];
            }
        }
    };

    Ajax.toQueryString = function(o, trad) {
        var prefix, i,
            traditional = trad || false,
            s = [],
            enc = encodeURIComponent,
            add = function(key, value) {
                // If value is a function, invoke it and return its value
                if (typeof value == 'function') {
                    value = value();
                } else {
                    value = value || '';
                }

                s[s.length] = enc(key) + '=' + enc(value);
            };

        // If an array was passed in, assume that it is an array of form elements.
        if (DG.Util.isArray(o)) {
            for (i = 0; o && i < o.length; i++) {
                add(o[i].name, o[i].value);
            }
        } else {
            // If traditional, encode the "old" way (the way 1.3.2 or older
            // did it), otherwise encode params recursively.
            for (prefix in o) {
                if (o.hasOwnProperty(prefix)) {
                    buildParams(prefix, o[prefix], traditional, add);
                }
            }
        }

        // spaces should be + according to spec
        return s.join('&').replace(/%20/g, '+');
    };

    var testxhr = win[xmlHttpRequest] ? new XMLHttpRequest() : null;

    Ajax.corsSupport = !(!(testxhr && 'withCredentials' in testxhr) && !win[xDomainRequest]) &&
        // cors not available in IE and with cyrillic domain
        !(DG.Browser.ie && document.location.host.toLowerCase().search(/[а-я]/) != -1);

    return Ajax;
})();


================================================
FILE: src/DGAjax/test/DGAjaxSpec.js
================================================
describe('DG.ajax', function () {

	describe('#toQueryString', function () {
		it('([{ name: x, value: y }, ... ]) simple', function () {
			var arr = [
				{ name: 'foo', value: 'bar' },
				{ name: 'baz', value: '' },
				{ name: 'x', value: -20 },
				{ name: 'x', value: 20 }
		    ];

			expect(DG.ajax.toQueryString(arr)).to.be.eql('foo=bar&baz=&x=-20&x=20');
		});

		it('([{ name: x, value: y }, ... ]) escaping required', function () {
			var arr = [
				{ name: 'dotted.name.intact', value: '$@%' },
				{ name: '$ $', value: 20 },
				{ name: 'leave britney alone', value: 'waa haa haa' }
			];

			expect(DG.ajax.toQueryString(arr)).to.be.eql('dotted.name.intact=%24%40%25&%24+%24=20&leave+britney+alone=waa+haa+haa');
		});
	});

    describe('send request', function() {
        var xhr, requests, url, data, ajax, spyError, spySuccess, thenSuccess, thenError, clock;

        before(function() {
            xhr = sinon.useFakeXMLHttpRequest();
            requests = [];

            xhr.onCreate = function (xhr) {
                requests.push(xhr);
            };
        });

        after(function() {
            xhr.restore();
            xhr = requests = url = data = ajax = spyError = spySuccess = thenSuccess = thenError = clock = null;
        });

        function testSuccess(type) {
            describe('type: ' + type + ', respond success', function() {
                before(function() {
                    url = 'http://test-url.ru';
                    data = {a: 1, b: 3};
                    spySuccess = sinon.spy();
                    spyError = sinon.spy();
                    thenSuccess = sinon.spy();
                    thenError = sinon.spy();

                    ajax = DG.ajax(url, {
                        data: data,
                        type: type,
                        success: spySuccess,
                        error: spyError
                    }).then(thenSuccess, thenError);
                });

                after(function() {
                    requests = [];
                    url = data = spyError = spySuccess = thenSuccess = thenError = null;
                });

                it('should only one request', function() {
                    expect(requests.length).to.be(1);
                });

                it('should sended request url contain url', function() {
                    expect(requests[0].url).to.contain(url);
                });

                it('should call success', function(done) {
                    requests[0].respond(200, {"Content-Type": "application/json"}, '[{ "z": 10, "x": "20" }]');

                    setTimeout(function() {
                        expect(spySuccess.calledOnce).to.be.ok();
                        done();
                    }, 0);
                });

                it('should call thenSuccess', function() {
                    expect(thenSuccess.calledOnce).to.be.ok();
                });

                it('shouldn\'t call error', function() {
                    expect(spyError.called).not.be.ok();
                });

                it('shouldn\'t call thenError', function() {
                    expect(thenError.called).not.be.ok();
                });
            });
        }

        testSuccess('get');
        testSuccess('post');

        describe('respond error', function() {
            before(function() {
                url = 'http://test-url.ru';
                data = {a: 1, b: 3};
                spySuccess = sinon.spy();
                spyError = sinon.spy();
                thenSuccess = sinon.spy();
                thenError = sinon.spy();

                ajax = DG.ajax(url, {
                    data: data,
                    type: 'post',
                    success: spySuccess,
                    error: spyError
                }).then(thenSuccess, thenError);
            });

            after(function() {
                requests = [];
                url = data = spyError = spySuccess = thenSuccess = thenError = null;
            });

            it('shouldn\'t call success', function(done) {
                requests[0].respond(400, {"Content-Type": "application/json"}, '[{ "z": 10, "x": "20" }]');

                setTimeout(function() {
                    expect(spySuccess.called).not.be.ok();
                    done();
                }, 0);
            });

            it('shouldn\'t call thenSuccess', function() {
                expect(thenSuccess.calledOnce).not.be.ok();
            });

            it('should call error', function() {
                expect(spyError.calledOnce).to.be.ok();
            });

            it('should call thenError', function() {
                expect(thenError.calledOnce).to.be.ok();
            });
        });

        describe('check timeout', function() {
            before(function() {
                url = 'http://test-url.ru';
                data = {a: 1, b: 3};
                spySuccess = sinon.spy();
                spyError = sinon.spy();
                thenSuccess = sinon.spy();
                thenError = sinon.spy();

                ajax = DG.ajax(url, {
                    data: data,
                    type: 'post',
                    success: spySuccess,
                    error: spyError,
                    timeout: 10
                }).then(thenSuccess, thenError);
            });

            after(function() {
                requests = [];
                url = data = spyError = spySuccess = thenSuccess = thenError = clock = null;
            });

            it('shouldn\'t call success after timeout', function(done) {
                setTimeout(function() {
                    requests[0].respond(200, {"Content-Type": "application/json"}, '[{ "z": 10, "x": "20" }]');

                    setTimeout(function() {
                        expect(spySuccess.called).not.be.ok();
                        expect(thenSuccess.called).not.be.ok();
                        done();
                    }, 0);
                }, 50);
            });
        });
    });
});


================================================
FILE: src/DGAttribution/lang/ar.js
================================================
DG.Control.Attribution.Dictionary.ar = {
    license_agreement: 'إتفاقية ترخيص',
    work_on: 'يعمل بتطبيق 2GIS',
    has_no_key: 'مطلوب مفتاح للتشغيل الصحيح لـ Raster JS API. المساعدة: api@2gis.ru',
    open_on: 'Open in 2GIS',
    route_on: 'Route on 2GIS'
};


================================================
FILE: src/DGAttribution/lang/cs.js
================================================
DG.Control.Attribution.Dictionary.cs = {
    license_agreement: 'Licenční smlouva',
    has_no_key: 'Pro správnou funkci Raster JS API je vyžadován klíč. Pomoc: api@2gis.ru',
    work_on: 'Pracuje na API 2GIS'
};


================================================
FILE: src/DGAttribution/lang/en.js
================================================
DG.Control.Attribution.Dictionary.en = {
    license_agreement: 'License agreement',
    has_no_key: 'A key is required for proper operation of Raster JS API. Help: api@2gis.ru',
    work_on: 'Uses 2GIS API'
};


================================================
FILE: src/DGAttribution/lang/es.js
================================================
DG.Control.Attribution.Dictionary.es = {
    license_agreement : 'Acuerdo de licencia',
    has_no_key: 'Se requiere una clave para el funcionamiento correcto de Raster JS API. Ayuda: api@2gis.ru',
    work_on: '2GIS API'
};


================================================
FILE: src/DGAttribution/lang/it.js
================================================
DG.Control.Attribution.Dictionary.it = {
    license_agreement : 'Accordo di licenza',
    has_no_key: 'È richiesta una chiave per il corretto funzionamento di Raster JS API. Aiuto: api@2gis.ru',
    work_on: '2GIS API'
};


================================================
FILE: src/DGAttribution/lang/ru.js
================================================
DG.Control.Attribution.Dictionary.ru = {
    license_agreement: 'Лицензионное соглашение',
    work_on: 'Работает на API 2ГИС',
    has_no_key: 'Для корректной работы Raster JS API нужен ключ. Помощь: api@2gis.ru',
    open_on: 'Открыть в 2ГИС',
    route_on: 'Доехать с 2ГИС'
};


================================================
FILE: src/DGAttribution/skin/basic/less/dg-mapcopyright.less
================================================
/* !important is overused here to protect copyright styles from occasional change */

.dg-attribution {
    background-color: transparent !important;

    .dg-attribution__copyright {
        display: flex !important;
        align-items: center !important;
        text-align: right !important;
        white-space: nowrap !important;
        font-size: 9px !important;
        font-family: Helvetica, Arial, sans-serif !important;
    }

    .dg-attribution__links {
        display: inline-block !important;
        margin: 0 !important;
        padding: 0 5px 0 0 !important;
    }

    .dg-attribution__link-item {
        padding: 0 !important;
        list-style-type: none !important;
    }

    .dg-attribution__warning-message {
        display: inline-block !important;
        margin: 0 !important;
        color: #333 !important;
        font-family: Helvetica, Arial, sans-serif !important;
        font-weight: bold !important;
        white-space: normal;
    }

    .dg-attribution__logo-url {
        .notRepeatableBgWithSizes('DGAttribution__logo');
        margin: 0 3px 0 0 !important;
    }

    .dg-attribution__open2gis-button {
        background: #ffffff !important;
        border-radius: 4px !important;
        box-shadow: 0 3px 5px rgba(0, 0, 0, 0.2) !important;
        padding: 4px 6px 4px 4px !important;
        position: relative !important;
        display: inline-block !important;
        box-sizing: border-box !important;
        text-align: left !important;
        text-decoration: none !important;
        line-height: 14px !important;
        font-style: normal !important;
        font-weight: 600 !important;
        font-size: 9px !important;
        cursor: pointer !important;
        transition: all .1s !important;
        height: 22px !important;
        min-width: 101px !important;

        .no-touch &:hover {
            transition: background .2s !important;
            background: #e7f3ff !important;
        }
    }

    .dg-attribution__open2gis-icon-button:before {
        display: inline-block !important;
        margin: -1px 4px 0 0 !important;
        width: 12px !important;
        height: 12px !important;
        background-size: contain !important;
        background-repeat: no-repeat !important;
        content: '' !important;
        vertical-align: middle !important;
    }

    .dg-attribution__button-wrapper {
        margin-left: 3px !important;
        .dg-attribution__open2gis-button {
            color: #454C4F !important;

            .no-touch &:hover {
                color: #286482 !important;
            }
        }
    }

    .dg-attribution__open2gis-button_name_open:before {
        .notRepeatableBgWithSizes('DGAttribution_pin');
    }
}

.leaflet-container .dg-attribution .dg-attribution__link {
    background: linear-gradient(to right, rgba(8, 8, 8, .3), rgba(8, 8, 8, .3) 100%) 0 95% repeat-x !important;
    background-size: 10px 1px !important;
    color: #333 !important;
    text-decoration: none !important;
    font-size: 9px !important;
    font-family: Helvetica, Arial, sans-serif !important;
    cursor: pointer !important;

    &:hover {
        background-image: linear-gradient(to right, #080808, #080808 100%) !important;
        color: #333 !important;
        text-decoration: none !important;
    }
}


================================================
FILE: src/DGAttribution/src/DGAttribution.js
================================================
/**
 * Компонент отвечающий за копирайт на карте. В нем выводяться различные ссылки плюс логотип или кнопка.
 *
 * 1. Если в опциях карты передан logotype: true то будет логотип 2GIS
 * 2. Если на карте нет маркеров, то будет кнопка "Открыть в 2ГИС" и ссылка на 2ГИС (openLink2gis config.main.json)
 * 3. Если на карте есть 1 маркер, то будет кнопка "Доехать с 2ГИС" и ссылка на 2ГИС с параметрами для построения маршрута до этого маркера (ppLink2gis config.main.json)
 *
 * Компонент подписывается на события добавления и удаления слоев в карте, метод _mapEvents).
 * Если добавляется/удаляется маркер, то он добавляется/удаляется в массив _markers,
 * а затем первый маркер из этого массива сохраняется в _markerToRoute.
 * Поиск проезда будет предлагаться до маркера _markerToRoute.
 */

DG.Control.Attribution.include(DG.Locale);
DG.Control.Attribution.Dictionary = {};
DG.Control.Attribution.include({
    options: {
        position: 'bottomright'
    },

    _getLink: function(linkType) {
        /* eslint-disable camelcase */
        var dictionary = {
            ru: {
                copyright_logo: 'https://2gis.ru/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_apilink: 'https://dev.2gis.ru/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_license: 'https://law.2gis.ru/api-rules/',
                open_link: 'https://2gis.ru',
            },

            kz: {
                copyright_logo: 'https://2gis.kz/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_apilink: 'https://dev.2gis.kz/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_license: 'https://law.2gis.kz/api-rules/',
                open_link: 'https://2gis.kz',
            },

            it: {
                copyright_logo: 'https://2gis.it/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_apilink: 'https://dev.2gis.com/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_license: 'https://law.2gis.it/licensing-agreement/',
                open_link: 'https://2gis.ru',
            },

            cz: {
                copyright_logo: 'https://praha.2gis.cz/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_apilink: 'https://dev.2gis.com/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_license: 'https://law.2gis.cz/api-rules/',
                open_link: 'https://2gis.ru',
            },

            cl: {
                copyright_logo: 'https://santiago.2gis.cl/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_apilink: 'https://dev.2gis.com/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_license: 'https://law.2gis.cl/api-rules/',
                open_link: 'https://2gis.ru',
            },

            cy: {
                copyright_logo: 'https://info.2gis.com.cy/lemesos?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_apilink: 'https://dev.2gis.com/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_license: 'https://law.2gis.com.cy/api-rules/',
                open_link: 'https://2gis.ru',
            },

            ae: {
                copyright_logo: 'https://2gis.ae/dubai?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_apilink: 'http://dev.2gis.com/?utm_source=copyright&utm_medium=map&utm_campaign=partners',
                copyright_license: 'https://law.2gis.ae/api-rules/',
                open_link: 'https://2gis.ae',
            }
        };
        /* eslint-enable camelcase */

        var countryCode = (this._countryCode in dictionary) ? this._countryCode : 'ru';

        return dictionary[countryCode][linkType];
    },

    _markerToRoute: undefined,
    _markers: [],

    _checkMarkerLayers: function() {
        this._markerToRoute = this._markers.length != 1 ? undefined : this._markers[0];
        this._update();
    },

    _mapEvents: {

        layeradd: function(e) {
            if (e.layer instanceof DG.Marker) {
                this._markers.push(e.layer)
                if (this._markers.length <= 2) {
                    this._checkMarkerLayers();
                }
            }
        },

        layerremove: function(e) {
            if (e.layer instanceof DG.Marker) {
                var currentMarkers = [];
                for (var i = 0; i < this._markers.length; i++) {
                    if (this._markers[i] !== e.layer) {
                        currentMarkers.push(this._markers[i])
                    }
                }
                this._markers = currentMarkers;
                if (this._markers.length <= 1) {
                    this._checkMarkerLayers();
                }
            }
        },

    },

    onAdd: function(map) {
        if (!map._copyright) {
            map._copyright = true;
            this._first = true;
        }

        this._isDefaultKey = !map.options.key;
        this._logotype = map.options.logotype;
        this._open2gis = this._getLink('open_link')

        this._map.on(this._mapEvents, this);

        map.attributionControl = this;
        this._container = DG.DomUtil.create('div', 'dg-attribution');
        DG.DomEvent.disableClickPropagation(this._container);

        for (var i in map._layers) {
            if (map._layers[i].getAttribution) {
                this.addAttribution(map._layers[i].getAttribution());
            }
        }

        this._update();

        DG.DomEvent
            .on(this._container, 'touchstart', this._updateLink, this)
        return this._container;
    },

    _updateLink: function(e) {
        if (e.target.name === 'linkButton') {
            this._open2gis = this._getOpenUrl();
            e.target.href = this._open2gis;
        }
    },

    _update: function(lang, countryCode) {
        if (!this._map) { return; }

        if (typeof countryCode !== 'undefined') {
            this._countryCode = countryCode;
        }

        var attribs = [];

        for (var i in this._attributions) {
            if (this._attributions[i]) {
                attribs.push(i);
            }
        }

        var prefixAndAttribs = [],
            copyright = '';

        if (this._first) {
            copyright = this._getAttributionHTML(lang);
        }

        if (this.options.prefix) {
            prefixAndAttribs.push(this.options.prefix);
        }
        if (attribs.length) {
            prefixAndAttribs.push(attribs.join(', '));
        }

        this._container.innerHTML = copyright + prefixAndAttribs.join(' | ');

    },


    _getOpenUrl: function() {
        if (this._markerToRoute) {
            return DG.Util.template(DG.config.ppLink2gis, {
                'gislink': this._getLink('open_link'),
                'center': this._map.getCenter().lng + ',' + this._map.getCenter().lat,
                'zoom': this._map.getZoom(),
                'rsType': this._map.getZoom() > 11 ? 'bus' : 'car',
                'point': this._markerToRoute._latlng.lng + ',' + this._markerToRoute._latlng.lat
            });
        }

        return DG.Util.template(DG.config.openLink2gis, {
            'gislink': this._getLink('open_link'),
            'center': this._map.getCenter().lng + ',' + this._map.getCenter().lat,
            'zoom': this._map.getZoom(),
        });
    },
    _getData: function(lang) {
        lang = lang || this._map.getLang();
        var btn =
        {
            name: 'open',
            label: this._markerToRoute ? this.t('route_on') : this.t('open_on'),
        }

        // Do not show link button if button don't have translate to current language or map options logotype set true
        var isHideButton = btn.label == 'open_on' || btn.label == 'route_on' || this._logotype;

        return {
            'logotype': isHideButton,
            'work_on': this.t('work_on'),
            'has_no_key': this._isDefaultKey ? this.t('has_no_key') : null,
            'lang': lang,
            'copyright_apilink': this._getLink('copyright_apilink'),
            'copyright_license': this._getLink('copyright_license'),
            'copyright_logo': this._getLink('copyright_logo'),
            'open2gis_link': this._open2gis,
            'open2gis_name': 'linkButton',
            'license_agreement': this.t('license_agreement'),
            'dir': lang !== 'ar' ? 'ltr' : 'rtl',
            'btn': btn
        };
    },
    _getAttributionHTML: function(lang) {
        return DG.dust('DGAttribution/copyright', this._getData(lang));
    },
    _renderTranslation: function(e) {
        this._update(e.lang);
    }
});

DG.Map.addInitHook(function() {
    if (!this._copyright) {
        DG.control.attribution().addTo(this);
    }
});


================================================
FILE: src/DGAttribution/templates/copyright.dust
================================================
<div class="dg-attribution__copyright">
    <ul class="dg-attribution__links">
        <li class="dg-attribution__link-item">
            <a href="{copyright_apilink}" target="_blank" class="dg-attribution__link" dir="{dir}">{work_on}</a>
        </li>
        <li class="dg-attribution__link-item">
            <a href="{copyright_license}" target="_blank" class="dg-attribution__link">{license_agreement}</a>
        </li>
        {?has_no_key}
            <li class="dg-attribution__warning-message">{has_no_key}</li>
        {/has_no_key}
    </ul>
    {?logotype}
    <a href="{copyright_logo}" target="_blank" class="dg-attribution__logo-url"></a>
    {:else}
        {#btn}
            <div class="dg-attribution__button-wrapper">
                <a class="dg-attribution__open2gis-button_name_{name} dg-attribution__open2gis-button dg-attribution__open2gis-icon-button"
                    {?open2gis_link}
                        href={open2gis_link} target="_blank" name={open2gis_name}
                    {:else}
                        href="javascript:void(0)"
                    {/open2gis_link}
                    >{label}</a>
            </div>
        {/btn}
    {/logotype}
</div>


================================================
FILE: src/DGAttribution/test/DGAttributionSpec.js
================================================
describe('DG.Control.Attribution', function() {
    var dictionaryLicense = {
            ru: 'соглашение',
            en: 'agreement',
            it: 'licenza',
            es: 'licencia',
            cs: 'smlouva'
        },

        latLngWithoutProject = [54.83391822270635, 80.34439086914064],
        latLngCenterNsk = [55.017493, 82.819576],

        mapContainer,
        map,
        attribution;

    before(function () {
        mapContainer = document.createElement('div');
        map = new DG.Map(mapContainer, {
            center: latLngCenterNsk,
            zoom: 15,
            key: window.__karma__.config.secretKey,
        });
        attribution = mapContainer.getElementsByClassName('dg-attribution')[0];
    });

    after(function() {
        dictionaryLicense = latLngWithoutProject = latLngCenterNsk = mapContainer = map = attribution = null;
    });

    describe('check init', function() {
        it('should html element 2gis copyright', function() {
            var el = attribution.getElementsByClassName('dg-attribution__copyright');

            expect(el.length).to.be(1);
        });
    });

    describe('change languages', function() {
        after(function() {
           map.setLang('ru');
        });

        Object.keys(dictionaryLicense).forEach(function(el) {
            it('should copyright html ' + el + ' word license', function() {
                map.setLang(el);
                expect(attribution.innerHTML).to.contain(dictionaryLicense[el]);
            });
        });
    });
});


================================================
FILE: src/DGCore/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>
    <title>DG.then demo</title>
    <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>
</head>
<body>
    <div id="map" style="width: 100%; height: 600px; border: 1px solid #ccc;"></div>
    <script type="text/javascript">
        var map,
        balloonHTML;

    DG.then(function () {
        map = new DG.Map('map', {
            center: new DG.LatLng(54.980206086231, 82.898068362003),
            zoom: 15,
            dgGeoclicker: true,
            key: DG.config.key || 'Your API access key'
        });
        balloonHTML = '<a href="http://www.2gis.ru/" target="_blank">\n\
            <img src="2gis-logo.png" alt="2GIS" title="2GIS" width="146" height="70" style="border: none"></a>\n\
            <p>Компания «ДубльГИС»</p>Тел.: (383) 363-05-55<br />Адрес: г. Новосибирск, Карла Маркса площадь, 7<br />\n\
            (МФК «Сан Сити»), 13 этаж';

        DG.marker([54.980206086231, 82.898068362003]).addTo(map).bindPopup(balloonHTML).openPopup();

    }).then(function () {
        console.log('second handler');
    }).then(function () {
        setTimeout(function (argument) {
            console.log('still works');
        }, 2000)
    });

    setTimeout(function (argument) {
        DG.then(function(){
            console.log('deffered handler');
        }).then(function () {
            console.log('another one');
        })
    }, 4000)

    </script>
</body>
</html>


================================================
FILE: src/DGCore/skin/basic/less/dg-core.less
================================================
[class^='dg-'],
[class^='dg-']:before,
[class^='dg-']:after {
    -webkit-box-sizing: content-box;
    -moz-box-sizing: content-box;
    box-sizing: content-box;
    margin: 0;
    padding: 0;
    vertical-align: baseline;
    font-weight: inherit;
    font-style: inherit;
    font-size: 1em;
    font-family: inherit;
    line-height: 1.2;
}

[class^='dg-'] > [class^='dg-']:last-child {
    margin-bottom: 0;
}

[class^='dg-'] img,
[class^='dg-'] abbr,
[class^='dg-'] fieldset {
    border: 0;
}

[class^='dg-'] blockquote,
[class^='dg-'] q {
    quotes: none;
}

[class^='dg-'] blockquote:before,
[class^='dg-'] blockquote:after,
[class^='dg-'] q:before,
[class^='dg-'] q:after {
    content: '';
    content: none;
}

[class^='dg-'] ul,
[class^='dg-'] ol {
    list-style: none;
}

[class^='dg-'] table {
    border-spacing: 0;
    border-collapse: collapse;
}

[class^='dg-'] caption,
[class^='dg-'] th {
    text-align: left;
}

[class^='dg-'] th,
[class^='dg-'] td {
    vertical-align: middle;
}

[class^='dg-'] input::-moz-focus-inner,
[class^='dg-'] button::-moz-focus-inner {
    padding: 0;
    border: 0;
}


================================================
FILE: src/DGCore/src/DGCore.js
================================================
require('leaflet');
require('html5shiv');

// DG inheritance
var oldDG = window.DG;
var DG = new (
    (function() {
        var DgApi = function() {},
            DgApiCore = function() {};

        DgApiCore.prototype = L;
        DgApi.prototype = new DgApiCore();

        return DgApi;
    })()
)();

for (var prop in oldDG) {
    if (oldDG.hasOwnProperty(prop) && typeof DG[prop] === 'undefined') {
        DG[prop] = oldDG[prop];
    }
}

window.__dgApi__ = window.__dgApi__ || {};
DG.version = window.__dgApi__.version;
DG.Icon.Default.imagePath  = '../img/vendors/leaflet';

// Improve IHandler
DG.Map.include({
    addHandler: function(name, HandlerClass) {
        if (!HandlerClass) { return this; }

        var options = this.options[name],
            param = (options === Object(options)) ? options : null,
            handler = this[name] = new HandlerClass(this, param);

        this._handlers.push(handler);

        if (options) {
            handler.enable();
        }

        return this;
    }
});

// Apply class to map container for detect when we dont need hover effects
DG.Map.addInitHook(function() {
    if (!DG.Browser.touchEnabled) {
        DG.DomUtil.addClass(this._container, 'no-touch');
    }
});

window.DG = DG;
module.exports = DG;


================================================
FILE: src/DGCore/src/DGplugin.js
================================================
DG.plugin = function(plugins) {
    var count,
        jsReg = new RegExp(/.js$/i),
        cssReg = new RegExp(/.css$/i);

    return new Promise(function(resolve) {
        function checkLoading() {
            count--;

            if (count === 0) {
                resolve();
            }
        }

        function appendJS(link) {
            var js = document.createElement('script');
            js.setAttribute('type', 'text/javascript');
            js.setAttribute('src', link);
            js.onload = function() {
                checkLoading();
            };
            js.onerror = function() {
                checkLoading();
            };
            // load/error for IE
            js.onreadystatechange = function() {
                if (js.readyState === 'complete' || js.readyState === 'loaded') {
                    checkLoading();
                }
            };

            document.getElementsByTagName('head')[0].appendChild(js);
        }

        function appendCSS(link) {
            var css = document.createElement('link');
            css.setAttribute('rel', 'stylesheet');
            css.setAttribute('type', 'text/css');
            css.setAttribute('href', link);
            document.getElementsByTagName('head')[0].appendChild(css);

            checkLoading();
        }

        function isJs(url) {
            return jsReg.test(url);
        }

        function isCss(url) {
            return cssReg.test(url);
        }

        function appendAsset(asset) {
            if (isJs(asset)) {
                appendJS(asset);
            } else if (isCss(asset)) {
                appendCSS(asset);
            } else {
                count--;
            }
        }

        if (DG.Util.isArray(plugins)) {
            count = plugins.length;
            plugins.forEach(function(plugin) {
                appendAsset(plugin);
            });
        }

        if (typeof plugins === 'string') {
            count = 1;
            appendAsset(plugins);
        }
    });
};


================================================
FILE: src/DGCore/src/DGthen.js
================================================
var handlers = window.__dgApi__.callbacks || [],
    chain = Promise.resolve();

handlers.forEach(function(handlers) {
    chain = chain.then(handlers[0], handlers[1]);
});

DG.then = function(resolve, reject) {
    return chain.then(resolve, reject);
};

// IE8 throw error if `chain.catch`
/* eslint-disable dot-notation, no-console */
chain['catch'](function(err) {
    console.error(err);
});
/* eslint-enable dot-notation, no-console */


================================================
FILE: src/DGCustomization/skin/basic/less/dg-customization.less
================================================
.dg-customization__marker {
    background-repeat: no-repeat;

    &:before {
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
        background-image: inherit;
        background-size: contain;
        background-repeat: no-repeat;
        transition: opacity ease-in-out .2s, transform ease-in-out .2s;
        transform: scale(1, 1);
        transform-origin: 50% 100%;
    }
}

.dg-customization__marker_type_mushroom {
    .notRepeatableBgWithSizes('DGCustomization__marker', true);
    transform-origin: 50% 100%;
    animation: dg-customization__show-marker .2s;

    &:focus {
        outline: 0;
    }

    .no-touch &:hover {
        .notRepeatableBg('DGCustomization__markerHover', true);
    }

    &:active,
    .no-touch &:active {
        .notRepeatableBg('DGCustomization__markerActive', true);
    }
}

@keyframes dg-customization__show-marker {
    from {
        opacity: 0;
    }
    to {
        opacity: 1;
    }
}

.dg-customization__marker_appear {
    background-position: 999px;

    &:before {
        content: '';
    }
}

.dg-customization__marker_disappear {
    background-position: 999px;
    pointer-events: none;

    &:before {
        visibility: hidden;
        content: '';
        opacity: 0;
        transform: scale(1.2, 1.8);
        animation: dg-customization__marker-to-callout .2s;
    }
}

@keyframes dg-customization__marker-to-callout {
    0% {
        visibility: visible;
        opacity: 1;
        transform: scale(1, 1);
    }
    100% {
        visibility: visible;
        opacity: 0;
        transform: scale(1.2, 1.8);
    }
}

.dg-dragging-false {
    touch-action: auto;
    -ms-touch-action: auto;
}

.dg-error-message {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    background-color: rgba(195,194,179,0.58);
    color: white;
    display: flex;
    justify-content: center;
    align-items: center;
    font-size: 24px;
    text-align: center;
    z-index: 9999;
    font-family: Helvetica, Arial, sans-serif;
    font-weight: Bold;
    pointer-events: none;
    box-sizing: border-box;
    padding: 0 20px;
}



================================================
FILE: src/DGCustomization/skin/basic/less/leaflet.ie.less
================================================
.leaflet-right {
    width: 40px;
}


================================================
FILE: src/DGCustomization/skin/basic/less/leaflet.less
================================================
.leaflet-container {
    z-index: 0;
    background: rgb(247, 243, 223);
    cursor: default;

    &:fullscreen {
        width: 100% !important;
        height: 100% !important;
    }
}

.leaflet-dragging,
.leaflet-dragging .leaflet-clickable,
.leaflet-dragging .leaflet-container {
    cursor: move;
}

.leaflet-control a:focus,
.leaflet-control a {
    outline: none !important;
}

.leaflet-container .leaflet-control-attribution {
    background-color: transparent;
    box-shadow: none;
}


================================================
FILE: src/DGCustomization/skin/basic/skin.config.js
================================================
DG.configTheme = DG.configTheme || {};

DG.configTheme.markersData = {
    iconSize: [22, 34],
    className: 'dg-customization__marker dg-customization__marker_type_mushroom',
    iconAnchor: [10, 32]
};


================================================
FILE: src/DGCustomization/src/DGCustomization.js
================================================
// Fix a lot of bugs with pinch-zooming
// See https://github.com/2gis/mapsapi/issues/327
DG.Map.mergeOptions({
    bounceAtZoomLimits: false
});

//Inject observing localization change
var controlAddTo = DG.Control.prototype.addTo;

DG.Control.include({
    addTo: function(map) {
        map.on('langchange', this._renderTranslation, this);

        return controlAddTo.call(this, map);
    },
    _renderTranslation: function() {}
});

// Just a copy of toPoint function
// https://github.com/Leaflet/Leaflet/blob/e079588573d0b0c649df95c3d6005373e87f323a/src/geometry/Point.js#L198-L222
function toPoint(x, y, round) {
    if (x instanceof DG.Point) {
        return x;
    }
    if (DG.Util.isArray(x)) {
        return new DG.Point(x[0], x[1]);
    }
    if (x === undefined || x === null) {
        return x;
    }
    if (typeof x === 'object' && 'x' in x && 'y' in x) {
        return new DG.Point(x.x, x.y);
    }
    return new DG.Point(x, y, round);
}

// Add ability to pass HTMLElement in DG.divIcon html parameter
// See https://github.com/Leaflet/Leaflet/pull/6571
// TODO: Remove it after updating leaflet at least to v1.5.0
DG.DivIcon.include({
    createIcon: function(oldIcon) {
        var div = (oldIcon && oldIcon.tagName === 'DIV') ? oldIcon : document.createElement('div'),
            options = this.options;

        if (options.html instanceof Element) {
            DG.DomUtil.empty(div);
            div.appendChild(options.html);
        } else {
            div.innerHTML = options.html !== false ? options.html : '';
        }

        if (options.bgPos) {
            var bgPos = toPoint(options.bgPos);
            div.style.backgroundPosition = (-bgPos.x) + 'px ' + (-bgPos.y) + 'px';
        }
        this._setIconStyles(div, 'icon');

        return div;
    },
});

// Add some browser detection
DG.Browser.safari51 = DG.Browser.safari && navigator.userAgent.indexOf('Version/5.1') !== -1;

// DG.Browser.touch checks whether touch events supported or not; touchEnabled checks if it's a touch device
var msPointer = navigator.msPointerEnabled && navigator.msMaxTouchPoints && !window.PointerEvent;
var pointer = (window.PointerEvent && navigator.pointerEnabled && navigator.maxTouchPoints) || msPointer;
var documentTouch = window.DocumentTouch && document instanceof window.DocumentTouch;
DG.Browser.touchEnabled = pointer || 'ontouchstart' in window || documentTouch;

// Applies 2GIS divIcon to marker
DG.Marker.prototype.options.icon = DG.divIcon(DG.configTheme.markersData);

// support old option clickable
var utilSetOptions = DG.Util.setOptions;

DG.setOptions = L.setOptions = DG.Util.setOptions = function(obj, options) {
    if (options && typeof options.clickable !== 'undefined') {
        options.interactive = options.clickable;
    }

    return utilSetOptions.call(this, obj, options);
};

DG.Layer.mergeOptions({
    nonBubblingEvents: ['click', 'dblclick', 'mouseover', 'mouseout', 'contextmenu']
});

L.Canvas.include({
    // overwrite the function without mousemove debounce as it breaks metalayers events
    _initContainer: function() {
        var container = this._container = document.createElement('canvas');

        L.DomEvent
            .on(container, 'mousemove', this._onMouseMove, this)
            .on(container, 'click dblclick mousedown mouseup contextmenu', this._onClick, this)
            .on(container, 'mouseout', this._handleMouseOut, this);

        this._ctx = container.getContext('2d');
    }
});

// Monitor geometry usage
// TODO: remove after successful research
if (DG.Path) {
    var pathInitialize = DG.Path.prototype.onAdd;

    DG.Path.include({
        onAdd: function(map) {
            return pathInitialize.call(this, map);
        },
    });
}


================================================
FILE: src/DGCustomization/src/DGMap.ApiKeyValidator.js
================================================
DG.ApiKeyValidator = DG.Class.extend({
    initialize: function(apiKey, mapContainer) {
        this.apiKey = apiKey;
        this.endpoint = DG.config.keyServer + apiKey + DG.config.keyServices;
        this.isLoading = false;
        this.attempts = 0;
        this.lastTimeout = undefined;
        this.request = null;
        this.MAX_ATTEMPTS = 4;
        this.keyRequestInterval = [0, 2, 2, 2];
        this.isErrorWasShown = false;
        this.mapContainer = mapContainer;
    },

    validate: function(callback) {
        if (this.isLoading) {
            return;
        }

        this.isLoading = true;
        this.attempts = 0;
        this._makeAttempt(callback);
    },

    validateKeyResponse: function() {
        this.validate(function(response) {
            if (!response || this._isResponseInvalid(response)) {
                this._showError();
            }
        }.bind(this));
    },

    _makeAttempt: function(callback) {
        if (this.attempts > 0) {
            this.lastTimeout = window.setTimeout(function() {
                this._clearLastTimeout();
                this._executeRequest(callback);
            }.bind(this), this.keyRequestInterval[this.attempts] * 1000);
        } else {
            this._executeRequest(callback);
        }
    },

    _isResponseInvalid: function(response) {
        return (
            response.meta.code === 400 ||
            response.meta.code === 404 ||
            response.result &&
            (!response.result.service.is_active ||
                !response.result.is_active ||
                !['ok', 'exceeded'].includes(response.result.service.status.code)
            )
        );
    },

    _showError: function() {

        if (!this.isErrorWasShown && this.mapContainer) {
            var errorMessage = DG.DomUtil.create('div', 'dg-error-message');
            errorMessage.innerHTML = 'Your RasterJS API key is invalid. Please contact api@2gis.com to get RasterJS API key.';
            this.mapContainer.appendChild(errorMessage);
            this.isErrorWasShown = true;
        }
    },

    _executeRequest: function(callback) {
        this.request = DG.ajax(this.endpoint, {
            type: 'GET',
            success: function(response) {
                this.isLoading = false;
                callback(response);
            }.bind(this),
            error: function(xhr) {
                this._handleError(callback, xhr.status);
            }.bind(this)
        });
    },

    _handleError: function(callback, status) {
        this.attempts++;

        if (this.attempts < this.MAX_ATTEMPTS) {
            this._makeAttempt(callback);
        } else {
            this.isLoading = false;
            callback({
                meta: {
                    code: status,
                    message: 'Failed to validate API key'
                },
            });
        }
    },

    _clearLastTimeout: function() {
        if (this.lastTimeout !== undefined) {
            clearTimeout(this.lastTimeout);
            this.lastTimeout = undefined;
        }
    },

    destroy: function() {
        this._clearLastTimeout();
        this.isLoading = false;
    }
});


================================================
FILE: src/DGCustomization/src/DGMap.BaseLayer.js
================================================
DG.Map.addInitHook(function() {
    var errorUrl = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAAEAAQMAAABmvDolAAAAA1BMVEX28t5R0k5UAAAAH0lEQVR4Xu3AAQkAAADCMPunNsdhWxwAAAAAAAAAwAEhAAABg2UP5AAAAABJRU5ErkJggg==';
    var errorRuUrl = DG.config.protocol + DG.config.baseUrl + '/img/nomap_ru.png';

    var TileLayer = DG.Browser.mobile ? DG.MobileTileLayer : DG.TileLayer;

    var BaseLayer = TileLayer.extend({
        initialize: function(url, options) {
            this._isDg = true;
            TileLayer.prototype.initialize.call(this, url, options);
        },

        getTiles: function() {
            return this._tiles;
        }
    });

    var apiKey = this.options.key || DG.config.key;
    var mapContainer = this.getContainer();
    var validator = new DG.ApiKeyValidator(apiKey, mapContainer);
    var showCommPoi = (this.options.showCommPoi ? '' : '&layerType=nc');
    validator.validateKeyResponse();

    var protocol = this.options.protocol || DG.config.secureProtocol;
    // Check that last symbol is colon, and if not add it
    if (protocol[protocol.length - 1] !== ':') {
        protocol = protocol + ':';
    }

    var tileUrl = protocol + (DG.Browser.retina ? DG.config.retinaTileServer : DG.config.tileServer) + showCommPoi;
    var arabicTileUrl = protocol +
        (DG.Browser.retina ? DG.config.arabicRetinaTileServer : DG.config.arabicTileServer) + showCommPoi;

    var previewTileUrl = protocol +
        (DG.Browser.retina ? DG.config.previewRetinaTileServer : DG.config.previewTileServer) + showCommPoi;
    var arabicPreviewTileUrl = protocol +
        (DG.Browser.retina ? DG.config.arabicPreviewRetinaTileServer : DG.config.arabicPreviewTileServer) + showCommPoi;

    this.baseLayer = new BaseLayer(tileUrl, {
        subdomains: '0123',
        errorTileUrl: this.getLang() === 'ru' ? errorRuUrl : errorUrl,
        detectRetina: DG.config.detectRetina,
        maxZoom: 19,
        maxNativeZoom: 19,
        zIndex: 0,
        updateWhenIdle: false, // it's okay with preview tiles
        previewUrl: previewTileUrl,
        key: apiKey,
        crossOrigin: true // force Origin request header
    });

    var currentTilesLang = ''; // 'ar' | ''

    function updateTileUrl() {
        var lang = this.getLang();
        var project = this.projectDetector && this.projectDetector.getProject();

        if (lang === 'ru' && !project) {
            this.baseLayer.options.errorTileUrl = errorRuUrl;
        } else {
            this.baseLayer.options.errorTileUrl = errorUrl;
        }

        // Change 2GIS tiles for Arabic language in Dubai project
        if (currentTilesLang === '' && lang === 'ar' && project && project.country_code === 'ae') {
            currentTilesLang = 'ar';
            this.baseLayer.setUrl(arabicTileUrl);
            if (this.baseLayer.setPreviewUrl) {
                this.baseLayer.setPreviewUrl(arabicPreviewTileUrl);
            }

        } else if (currentTilesLang === 'ar' && (lang !== 'ar' || (!project || project.country_code !== 'ae'))) {
            currentTilesLang = '';
            this.baseLayer.setUrl(tileUrl);
            if (this.baseLayer.setPreviewUrl) {
                this.baseLayer.setPreviewUrl(previewTileUrl);
            }
        }
    }

    updateTileUrl.call(this);

    this.baseLayer.addTo(this);

    this.on({
        langchange: updateTileUrl,
        projectchange: updateTileUrl,
        projectleave: updateTileUrl
    }, this);
});


================================================
FILE: src/DGCustomization/src/DGMap.Drag.js
================================================
/**
 * This customization fixes unwanted inertia movement after sudden drag stops
 * See https://github.com/Leaflet/Leaflet/pull/4048.
 * If this PR ever gets merged, this file can be removed.
 */
var onDragEnd = DG.Map.Drag.prototype._onDragEnd;

DG.Map.Drag.include({
    _rememberTimeAndPosition: function() {
        var time = this._lastTime = +new Date(),
            pos = this._lastPos = this._draggable._absPos || this._draggable._newPos;

        this._positions.push(pos);
        this._times.push(time);

        // Remove all data points older than 50 ms
        while (time - this._times[0] > 50) {
            this._positions.shift();
            this._times.shift();
        }
    },

    _onDrag: function(e) {
        if (this._map.options.inertia) {
            this._rememberTimeAndPosition();
        }

        this._map
            .fire('move', e)
            .fire('drag', e);
    },

    _onDragEnd: function() {
        if (this._map.options.inertia && !DG.Browser.touch) {
            this._rememberTimeAndPosition();
        }

        onDragEnd.call(this);
    }
});


================================================
FILE: src/DGCustomization/src/DGMap.TilesCheck.js
================================================
DG.Map.mergeOptions({
    tilesCheck: true
});

DG.Map.TilesCheck = DG.Handler.extend({
    initialize: function(map) {
        this._map = map;
        this._layer = map.baseLayer;

        this._moveStartEventCounter = 0;
        this._moveEndEventCounter = 0;

        this._loadingEventCounter = 0;
        this._loadEventCounter = 0;
    },

    addHooks: function() {
        this._map.on(this._mapEvents, this);
        this._layer.on(this._layerEvents, this);
    },

    removeHooks: function() {
        this._map.off(this._mapEvents, this);
        this._layer.off(this._layerEvents, this);
    },

    _mapEvents: {
        layeradd: function(e) {
            if (e.layer == this._layer) {
                this.enable();
            }
        },

        layerremove: function(e) {
            if (e.layer == this._layer) {
                this.disable();
            }
        },

        movestart: function() {
            this._stopWaiting();

            this._moveStartEventCounter++;
            this._isWaiting = true;
        },

        moveend: function() {
            this._moveEndEventCounter++;

            if (!this._isWaiting && this._moveStartEventCounter !== this._moveEndEventCounter) { return; }

            this._isMoveEnd = true;

            this._checkWaiting();
        }
    },

    _layerEvents: {
        loading: function() {
            this._loadingEventCounter++;
        },

        load: function() {
            this._loadEventCounter++;

            if (!this._isWaiting && this._loadingEventCounter !== this._loadEventCounter) { return; }

            this._isLoad = true;

            this._checkWaiting();
        }
    },

    _stopWaiting: function() {
        this._isWaiting = false;
        this._isMoveEnd = false;
        this._isLoad = false;
    },

    _checkWaiting: function() {
        if (this._isWaiting && this._isLoad && this._isMoveEnd) {
            this._stopWaiting();
            this._resetCounters();
            this._checkTiles();
        }
    },

    _checkTiles: function() {
        if (this._map.getTileLayersNumber() !== 0 || !this._map._loaded) { return; }

        var tileZoom = this._layer._tileZoom;
        var errorUrl = this._layer.options.errorTileUrl;
        var tiles = this._layer.getTiles();

        for (var i in tiles) {
            if (tiles[i].coords.z === tileZoom && tiles[i].el.src !== errorUrl) {
                return;
            }
        }

        this._map.zoomOut();
    },

    _resetCounters: function() {
        this._moveStartEventCounter = 0;
        this._moveEndEventCounter = 0;

        this._loadingEventCounter = 0;
        this._loadEventCounter = 0;
    }
});

DG.Map.addInitHook('addHandler', 'tilesCheck', DG.Map.TilesCheck);


================================================
FILE: src/DGCustomization/src/DGMap.js
================================================
var initMap = DG.Map.prototype.initialize,
    panBy = DG.Map.prototype.panBy,
    getBoundsZoom = DG.Map.prototype.getBoundsZoom,
    setMaxZoom = DG.Map.prototype.setMaxZoom;

// Restrict zoom level according to 2gis projects, in case if dgTileLayer is only one
DG.Map.include({

    // number of tileLayers without 2gis layers
    _tileLayersNumber: 0,

    _mapMaxZoomCache: null,

    //TODO try refactor it after up on new leaflet (> 0.7)
    initialize: function(id, options) { // (HTMLElement or String, Object)
        // Override default wheelPxPerZoomLevel value to avoid zooming too fast
        // on mouse wheel rotation
        // See https://github.com/2gis/mapsapi/issues/343
        options = DG.extend({wheelPxPerZoomLevel: 10000}, options);

        this.metaLayers = [];

        initMap.call(this, id, options);

        //  Project must be checked after BaseLayer init which occurs in InitHook (see orig method definition)
        if (this.options.center && this.options.zoom !== undefined) {
            this.setView(DG.latLng(this.options.center), this.options.zoom, {reset: true});
        }

        this._lastMetalayer = {
            layer: undefined,
            entity: undefined
        };
    },

    setView: function(center, zoom, options) {
        this._restrictZoom(center, zoom);

        zoom = zoom === undefined ? this._zoom : this._limitZoom(zoom);
        center = this._limitCenter(DG.latLng(center), zoom, this.options.maxBounds);
        options = options || {};

        if (options.animate) {
            options.animate = this._testAnimation(center);
        }

        this._stop();

        if (this._loaded && !options.reset && options !== true) {

            if (options.animate !== undefined) {
                options.zoom = DG.extend({
                    animate: options.animate,
                    duration: options.duration
                }, options.zoom);
                options.pan = DG.extend({
                    animate: options.animate,
                    duration: options.duration
                }, options.pan);
            }

            // try animating pan or zoom
            var animated = (this._zoom !== zoom) ?
                this._tryAnimatedZoom && this._tryAnimatedZoom(center, zoom, options.zoom) :
                this._tryAnimatedPan(center, options.pan);

            if (animated) {
                // prevent resize handler call, the view will refresh after animation anyway
                clearTimeout(this._sizeTimer);
                return this;
            }
        }

        // animation didn't start, just reset the map view
        this._resetView(center, zoom);

        return this;
    },

    panBy: function(offset, options) {
        var map = panBy.call(this, offset, options);

        var zoom = this._restrictZoom(this.getCenter());
        if (this.getZoom() > zoom) {
            this.setZoom(zoom);
        }

        return map;
    },

    getBoundsZoom: function(bounds, inside, padding) {
        bounds = DG.latLngBounds(bounds);
        this._restrictZoom(bounds);
        return getBoundsZoom.call(this, bounds, inside, padding);
    },

    getTileLayersNumber: function() {
        return this._tileLayersNumber;
    },

    setMaxZoom: function(zoom) {
        this._mapMaxZoomCache = null;
        return setMaxZoom.call(this, zoom);
    },

    _testAnimation: function(coords) {//if we jump to other project - disable animation
        if (this.projectDetector.enabled()) {
            var projectFrom = this.projectDetector.getProject(),
                projectTo = this.projectDetector.isProjectHere(coords);

            if (projectFrom && projectTo) {
                return projectFrom.code === projectTo.code;
            }
        }

        return true;
    },

    _updateTileLayers: function(e) {
        if (!(e.layer instanceof DG.TileLayer) || e.layer._isDg) { return; }

        if (e.type === 'layeradd') {
            this._tileLayersNumber++;
        } else {
            this._tileLayersNumber--;
        }
    },

    _getNewBounds: function(coords, zoom) {
        if (coords instanceof DG.LatLngBounds) {
            return coords;
        }

        var point = this.project(coords, zoom);
        var screenSize = this.getSize().divideBy(2);

        var sw = this.unproject(point.subtract(screenSize), zoom);
        var ne = this.unproject(point.add(screenSize), zoom);

        return DG.latLngBounds(sw, ne);
    },

    _restrictZoom: function(coords, zoom) {
        if (this._layers &&
            this.projectDetector.enabled() &&
            (this._tileLayersNumber === 0)) {

            var mapOptions = this.options,
                isMapMaxZoom = !!mapOptions.maxZoom,
                dgTileLayer = this.baseLayer,
                bounds = this._getNewBounds(coords, zoom),
                project = this.projectDetector.isProjectHere(bounds);

            if (isMapMaxZoom) {
                if (!this._mapMaxZoomCache) {
                    if (this.baseLayer.options.detectRetina && DG.Browser.retina && mapOptions.maxZoom > 0) {
                        mapOptions.maxZoom--;
                    }

                    this._mapMaxZoomCache = mapOptions.maxZoom;
                }
                mapOptions.maxZoom = (this._mapMaxZoomCache && project) ? this._mapMaxZoomCache :  DG.config.projectLeaveMaxZoom;
                if (project) {
                    this._mapMaxZoomCache = mapOptions.maxZoom;
                }

                return mapOptions.maxZoom;
            } else {
                if (project) {
                    if (dgTileLayer.options.detectRetina && DG.Browser.retina && project.maxZoom > 0) {
                        dgTileLayer.options.maxZoom = project.maxZoom - 1;
                    } else {
                        dgTileLayer.options.maxZoom = project.maxZoom;
                    }
                } else {
                    dgTileLayer.options.maxZoom = DG.config.projectLeaveMaxZoom;
                }

                dgTileLayer.options.maxNativeZoom = dgTileLayer.options.maxZoom;
                this._updateZoomLevels();

                return dgTileLayer.options.maxZoom;
            }
        }
    },

    // Added meta layers events processing before map events
    _fireDOMEvent: function(e, type, targets) {
        if (e.keyCode === 13) {
            // https://github.com/Leaflet/Leaflet/issues/5499
            return;
        }
        if (e.type === 'click') {
            // Fire a synthetic 'preclick' event which propagates up (mainly for closing popups).
            // @event preclick: MouseEvent
            // Fired before mouse click on the map (sometimes useful when you
            // want something to happen on click before any existing click
            // handlers start running).
            var synth = L.Util.extend({}, e);
            synth.type = 'preclick';
            this._fireDOMEvent(synth, synth.type, targets);
        }

        if (e._stopped) { return; }

        // Find the layer the event is propagating from and its parents.
        targets = (targets || []).concat(this._findEventTargets(e, type));

        if (!targets.length) { return; }

        var target = targets[0];
        if (type === 'contextmenu' && target.listens(type, true)) {
            L.DomEvent.preventDefault(e);
        }

        // The eventTargets and eventTargetsMapIndex properties are used for fire events continuation to
        // remaining targets when the event was stopped due to the tile meta data request in progress.
        // In this case there is need to fire events to remaining targets asynchronously.
        var data = {
            originalEvent: e,
            eventTargets: targets,
            eventTargetsMapIndex: targets.indexOf(this)
        };

        if (e.type !== 'keypress') {
            var isMarker = target instanceof L.Marker;
            data.containerPoint = isMarker ?
                this.latLngToContainerPoint(target.getLatLng()) : this.mouseEventToContainerPoint(e);
            data.layerPoint = this.containerPointToLayerPoint(data.containerPoint);
            data.latlng = isMarker ? target.getLatLng() : this.layerPointToLatLng(data.layerPoint);
        }

        for (var i = 0; i < targets.length; i++) {
            // Check metalayers before dispatch the event to the map
            if (targets[i] === this) {
                var metalayer = this._getCurrentMetaLayer(data);

                if (type === 'mousemove') {
                    if (this._lastMetalayer.entity && metalayer.entity &&
                        this._lastMetalayer.entity.id === metalayer.entity.id) {
                        this._fireMetalayerEvent('mousemove', metalayer, data);
                    } else {
                        this._fireMetalayerEvent('mouseout', this._lastMetalayer, data);
                        this._fireMetalayerEvent('mouseover', metalayer, data);
                        this._fireMetalayerEvent('mousemove', metalayer, data);
                        this._lastMetalayer = metalayer;
                    }
                } else {
                    this._fireMetalayerEvent(type, metalayer, data);
                }

                // If the event wasn't stopped in metalayers, dispatch it to the map
                if (!data.originalEvent._stopped) {
                    targets[i].fire(type, data, true);
                }
            } else {
                targets[i].fire(type, data, true);
                if (this._lastMetalayer.entity && data.originalEvent._stopped) {
                    // fixes L.circle([54.983136831455, 82.897440725094], 200).addTo(map);
                    this._fireMetalayerEvent('mouseout', this._lastMetalayer, data);
                    this._lastMetalayer = {
                        layer: undefined,
                        entity: undefined
                    };
                }
            }

            if (data.originalEvent._stopped ||
                (targets[i].options.nonBubblingEvents && L.Util.indexOf(targets[i].options.nonBubblingEvents, type) !== -1)) { return; }
        }
    },

    _getCurrentMetaLayer: function(data) {
        // Not forget for IE8 with srcElement
        var eventTarget = data.originalEvent.target || data.originalEvent.srcElement;
        var isClick = data.originalEvent.type === 'click';

        // Suppose that user can interact with the metalayer only if there are no layers between cursor and map
        if (
            // For all browsers which support pointer-events: none on tiles
            eventTarget === this._container ||
            // And for IE10 or less where targets are tiles
            DG.Browser.ie && eventTarget.className === 'leaflet-tile leaflet-tile-loaded' ||
            // The only exception is canvas, because a canvas layer occupies the whole screen
            eventTarget.tagName === 'CANVAS'
        ) {
            for (var j = this.metaLayers.length - 1; j >= 0; j--) {
                var metaEntity = this.metaLayers[j].getHoveredObject(data);
                if (metaEntity) {
                    return {
                        layer: this.metaLayers[j],
                        entity: metaEntity
                    };
                } else if (isClick) {
                    // Additional condition for click event, because there may not be the tile meta data.
                    // E.g. when the tile meta data request in progress. In this case the metalayer must be
                    // returned without an entity.
                    return {
                        layer: this.metaLayers[j],
                        entity: undefined
                    }
                }
            }
        }
        return {
            layer: undefined,
            entity: undefined
        };
    },

    _fireMetalayerEvent: function(type, metalayer, data) {
        // There is need to continue if the event type is click, because there may not be the tile meta data.
        // That's why it will be processed in the metalayer click handler.
        if (!metalayer.entity && type !== 'click') {
            return;
        }

        // There is no need to fire metalayer event if the metalayer is undefined.
        if (!metalayer.layer) {
            return;
        }

        var listener = metalayer.layer.mapEvents[type];
        if (!listener) {
            return;
        }
        data.entity = metalayer.entity;
        listener.call(metalayer.layer, data);
    }
});

DG.Map.addInitHook(function() {
    this.on('layeradd layerremove', this._updateTileLayers);
});

// Set css property touch-action to auto if dragging is false.
// Need for scrolling page in mobile using our map dom element.
// todo: I made issue in leaflet https://github.com/Leaflet/Leaflet/issues/4415
DG.Map.addInitHook(function() {
    if (this.options.dragging == false && this.options.tap == false) {
        DG.DomUtil.addClass(this._container, 'dg-dragging-false');
    }
});


================================================
FILE: src/DGCustomization/src/DGMobileImprove.js
================================================
/**
 * В файле содежатся изменения для ускорения лифлета на мобильных девайсах
 */

if (DG.Browser.mobile) {
    (function() {
        /**
         * Хакаем addClass и removeClass, чтобы они не работали для определённых классов
         * Сделано так, чтобы не менять кучу методов в кишках лифлета
         *
         * leaflet-dragging и leaflet-drag-target вызывает длинный recalculate style
         */
        var addClass = L.DomUtil.addClass;
        L.DomUtil.addClass = function(el, name) {
            if (name === 'leaflet-dragging' ||
                name === 'leaflet-drag-target'
            ) {
                return;
            }

            addClass(el, name);
        };

        var removeClass = L.DomUtil.removeClass;
        L.DomUtil.removeClass = function(el, name) {
            if (name === 'leaflet-dragging' ||
                name === 'leaflet-drag-target'
            ) {
                return;
            }

            removeClass(el, name);
        }

        L.Draggable.include({
            /**
             * Добавлено округление позиции this._startPos.add(offset)._round()
             * И сравнение с предудыщей if (this._newPos && this._newPos.x == pos.x && this._newPos.y == pos.y) {
             * Чтобы обновление dom происходило только при реальном изменении
             * Убраны классы leaflet-dragging и leaflet-drag-target
             */
            _onMove: function(e) {
                // Ignore simulated events, since we handle both touch and
                // mouse explicitly; otherwise we risk getting duplicates of
                // touch events, see #4315.
                // Also ignore the event if disabled; this happens in IE11
                // under some circumstances, see #3666.
                if (e._simulated || !this._enabled) { return; }

                if (e.touches && e.touches.length > 1) {
                    this._moved = true;
                    return;
                }

                var first = (e.touches && e.touches.length === 1 ? e.touches[0] : e),
                    newPoint = new L.Point(first.clientX, first.clientY),
                    offset = newPoint.subtract(this._startPoint);

                if (!offset.x && !offset.y) { return; }
                if (Math.abs(offset.x) + Math.abs(offset.y) < this.options.clickTolerance) { return; }

                L.DomEvent.preventDefault(e);

                if (!this._moved) {
                    // @event dragstart: Event
                    // Fired when a drag starts
                    this.fire('dragstart');

                    this._moved = true;
                    this._startPos = L.DomUtil.getPosition(this._element).subtract(offset);

                    this._lastTarget = e.target || e.srcElement;
                    // IE and Edge do not give the <use> element, so fetch it
                    // if necessary
                    if ((window.SVGElementInstance) && (this._lastTarget instanceof window.SVGElementInstance)) {
                        this._lastTarget = this._lastTarget.correspondingUseElement;
                    }
                }

                var pos = this._startPos.add(offset)._round();
                this._moving = true;

                L.Util.cancelAnimFrame(this._animRequest);
                this._lastEvent = e;

                if (this._newPos && this._newPos.x == pos.x && this._newPos.y == pos.y) {
                    return;
                }

                this._newPos = pos;
                this._animRequest = L.Util.requestAnimFrame(this._updatePosition, this, true);
            }
        });

        /**
         * Длительность всех инерций при движении карты теперь 1 секунда
         */
        L.Map.Drag.include({
            _onDragEnd: function(e) {
                var map = this._map,
                    options = map.options,

                    noInertia = !options.inertia || this._times.length < 2;

                map.fire('dragend', e);

                if (noInertia) {
                    map.fire('moveend');

                } else {

                    var direction = this._lastPos.subtract(this._positions[0]),
                        duration = (this._lastTime - this._times[0]) / 1000,
                        ease = options.easeLinearity,

                        speedVector = direction.multiplyBy(ease / duration),
                        speed = speedVector.distanceTo([0, 0]),

                        limitedSpeed = Math.min(options.inertiaMaxSpeed, speed),
                        limitedSpeedVector = speedVector.multiplyBy(limitedSpeed / speed),

                        decelerationDuration = 1, // limitedSpeed / (options.inertiaDeceleration * ease),
                        offset = limitedSpeedVector.multiplyBy(-decelerationDuration / 2).round();

                    if (!offset.x && !offset.y) {
                        map.fire('moveend');

                    } else {
                        offset = map._limitOffset(offset, map.options.maxBounds);

                        L.Util.requestAnimFrame(function() {
                            map.panBy(offset, {
                                duration: decelerationDuration,
                                easeLinearity: ease,
                                noMoveStart: true,
                                animate: true
                            });
                        });
                    }
                }
            }
        })
    })();
}

L.MobileTileLayer = L.TileLayer.extend({
    initialize: function(url, options) {
        L.TileLayer.prototype.initialize.call(this, url, options);
        this._appleDevice = this._isAppleDevice()
        this._previewUrl = options.previewUrl;
    },

    setPreviewUrl: function(url) {
        this._previewUrl = url;
        this.redraw();
    },

    /**
     * Быстрое навешивание событий, вместо L.DomUtil.on используем простое присваивание
     */
    createTile: function(coords, done, url) {
        var tile = document.createElement('img');
        tile.onload = L.bind(this._tileOnLoad, this, done, tile);
        tile.onerror = L.bind(this._tileOnError, this, done, tile);

        if (this.options.crossOrigin) {
            tile.crossOrigin = '';
        }

        /*
         Alt tag is set to empty string to keep screen readers from reading URL and for compliance reasons
         http://www.w3.org/TR/WCAG20-TECHS/H67
        */
        tile.alt = '';
        tile.src = this.getTileUrl(coords, url);

        return tile;
    },

    /**
     * Убран класс leaflet-tile
     * Добавлен хак для превью тайлов
     */
    _initTile: function(tile) {
        tile.style.position = 'absolute';

        var tileSize = this.getTileSize();
        tile.style.width = tileSize.x + 'px';
        tile.style.height = tileSize.y + 'px';

        tile.style.visibility = 'hidden';
        tile.style.pointerEvents = 'none';

        tile.onselectstart = L.Util.falseFn;
        tile.onmousemove = L.Util.falseFn;

        // without this hack, tiles disappear after zoom on Chrome for Android
        // https://github.com/Leaflet/Leaflet/issues/2078
        if (L.Browser.android && !L.Browser.android23) {
            tile.style.WebkitBackfaceVisibility = 'hidden';
        }

        return tile;
    },

    /**
     * Убран класс leaflet-tile-container
     */
    _updateLevels: function() {

        var zoom = this._tileZoom,
            maxZoom = this.options.maxZoom;

        if (zoom === undefined) { return undefined; }

        for (var z in this._levels) {
            if (this._levels[z].el.children.length || z === zoom) {
                this._levels[z].el.style.zIndex = maxZoom - Math.abs(zoom - z);
            } else {
                L.DomUtil.remove(this._levels[z].el);
                this._removeTilesAtZoom(z);
                delete this._levels[z];
            }
        }

        var level = this._levels[zoom],
            map = this._map;

        if (!level) {
            level = this._levels[zoom] = {};

            level.el = L.DomUtil.create('div', 'leaflet-zoom-animated', this._container);

            level.el.style.zIndex = maxZoom;

            level.origin = map.project(map.unproject(map.getPixelOrigin()), zoom).round();
            level.zoom = zoom;

            this._setZoomTransform(level, map.getCenter(), map.getZoom());

            // force the browser to consider the newly added element for transition
            L.Util.falseFn(level.el.offsetWidth);
        }

        this._level = level;

        return level;
    },

    /**
     * Убрано добавление тайлов через documentFragment
     */
    _update: function(center) {
        var map = this._map;
        if (!map) { return; }
        var zoom = map.getZoom();

        if (center === undefined) { center = map.getCenter(); }
        if (this._tileZoom === undefined) { return; }	// if out of minzoom/maxzoom

        var pixelBounds = this._getTiledPixelBounds(center),
            tileRange = this._pxBoundsToTileRange(pixelBounds),
            tileCenter = tileRange.getCenter(),
            queue = [],
            margin = this.options.keepBuffer,
            noPruneRange = new L.Bounds(tileRange.getBottomLeft().subtract([margin, -margin]),
                tileRange.getTopRight().add([margin, -margin]));

        for (var key in this._tiles) {
            var c = this._tiles[key].coords;
            if (c.z !== this._tileZoom || !noPruneRange.contains(L.point(c.x, c.y))) {
                this._tiles[key].current = false;
            }
        }

        // _update just loads more tiles. If the tile zoom level differs too much
        // from the map's, let _setView reset levels and prune old tiles.
        if (Math.abs(zoom - this._tileZoom) > 1) { this._setView(center, zoom); return; }

        // create a queue of coordinates to load tiles from
        for (var j = tileRange.min.y; j <= tileRange.max.y; j++) {
            for (var i = tileRange.min.x; i <= tileRange.max.x; i++) {
                var coords = new L.Point(i, j);
                coords.z = this._tileZoom;

                if (!this._isValidTile(coords)) { continue; }

                var tile = this._tiles[this._tileCoordsToKey(coords)];
                if (tile) {
                    tile.current = true;
                } else {
                    queue.push(coords);
                }
            }
        }

        // sort tile queue to load tiles in order of their distance to center
        queue.sort(function(a, b) {
            return a.distanceTo(tileCenter) - b.distanceTo(tileCenter);
        });

        if (queue.length !== 0) {
            // if it's the first batch of tiles to load
            if (!this._loading) {
                this._loading = true;
                // @event loading: Event
                // Fired when the grid layer starts loading tiles.
                this.fire('loading');
            }

            for (i = 0; i < queue.length; i++) {
                this._addTile(queue[i], this._level.el);
            }
        }
    },

    /**
     * We don't load preview tile:
     * - after zoom-in if a tile from a lower zoom is already shown
     * - after zoom-out if four tiles from a higher zoom is already shown
     */
    _needPreviewTile: function(coords) {
        if (this._tileZoom - this._map.getZoom() > 0) {
            // zoom in
            return !this._existTileFromLowerZoom(coords);
        } else {
            // zoom out
            return !this._existTilesFromHigherZoom(coords);
        }
    },

    _existTileFromLowerZoom: function(coords) {
        var coords2 = L.point(coords.x / 2, coords.y / 2)._floor();

        coords2.z = coords.z - 1;

        var key = this._tileCoordsToKey(coords2);
        var tile = this._tiles[key];
        return tile && !tile.preview;
    },

    _existTilesFromHigherZoom: function(coords) {
        var x = coords.x;
        var y = coords.y;

        for (var i = 2 * x; i < 2 * x + 2; i++) {
            for (var j = 2 * y; j < 2 * y + 2; j++) {
                var c = new L.Point(i, j);
                c.z = coords.z + 1;
                var key = this._tileCoordsToKey(c);
                if (!this._tiles[key]) {
                    return false;
                }
            }
        }

        return true;
    },

    _isAppleDevice: function() {
        var appleMobileRE = /ip(hone|od)/i;
        var appleTabletRE = /ipad/i;
        var touchMacRE = /Macintosh/i;

        var ua = typeof navigator !== 'undefined' ? navigator.userAgent : '';

        if (!ua) {
            return false;
        }

        var isAppleMobile = appleMobileRE.test(ua);
        var isAppleTablet = appleTabletRE.test(ua);

        var isTouchMac =
            navigator.maxTouchPoints > 1 && touchMacRE.test(ua) && ua.indexOf('Safari') !== -1;

        return isAppleMobile || isAppleTablet || isTouchMac;
    },

    /**
     * Добавлена логика с превью тайлами
     */
    _addTile: function(coords, container) {
        var tilePos = this._getTilePos(coords),
            key = this._tileCoordsToKey(coords);

        var wrapCoords = this._wrapCoords(coords);
        var needPreview = this._needPreviewTile(wrapCoords);

        var url = needPreview ? this._previewUrl : this._url;
        var showPreviewForIphone = this._appleDevice && needPreview;
        var tile = this.createTile(wrapCoords, L.bind(showPreviewForIphone ? this._previewReady : this._tileReady, this, coords), url);

        this._initTile(tile);

        L.DomUtil.setPosition(tile, tilePos);

        // save tile in cache
        this._tiles[key] = {
            el: tile,
            preview: needPreview,
            coords: coords,
            current: true
        };

        container.appendChild(tile);
        // @event tileloadstart: TileEvent
        // Fired when a tile is requested and starts loading.
        this.fire('tileloadstart', {
            tile: tile,
            coords: coords
        });
    },

    _previewReady: function(coords, err, tile) {
        if (!this._map) { return; }

        var key = this._tileCoordsToKey(coords);

        tile = this._tiles[key];
        if (!tile) { return; }


        tile.el.onload = L.bind(this._tileReady, this, coords, err, tile);
        tile.el.onerror = L.bind(this._tileReady, this, coords, err, tile);
        tile.el.src = this.getTileUrl(coords, this._url);
    },

    /**
     * Убран fadeAnimated и класс leaflet-tile-loaded
     */
    _tileReady: function(coords, err, tile) {
        if (!this._map) { return; }

        if (err) {
            // @event tileerror: TileErrorEvent
            // Fired when there is an error loading a tile.
            this.fire('tileerror', {
                error: err,
                tile: tile,
                coords: coords
            });
        }

        var key = this._tileCoordsToKey(coords);

        tile = this._tiles[key];
        if (!tile) { return; }

        if (!this._appleDevice) {
        // Если у тайла уже есть оригинальная (не пожатая) картинка,
        // то заменим превью на нее
            if (tile.originalEl && tile.el.parentNode) {
                tile.el.parentNode.replaceChild(tile.originalEl, tile.el);
                tile.el = tile.originalEl;

                tile.originalEl = null;
                tile.preview = false;

                // Если у тайла есть только превью, то добавим его на карту
                // И начнем грузить оригинальный
            } else if (tile.preview) {
                tile.originalEl = this.createTile(this._wrapCoords(coords), L.bind(this._tileReady, this, coords), this._url);
                this._initTile(tile.originalEl);
                L.DomUtil.setPosition(tile.originalEl, this._getTilePos(coords));
            }
        }
        tile.loaded = +new Date();
        tile.active = true;
        this._pruneTiles();

        if (!err) {
            tile.el.style.visibility = '';

            // @event tileload: TileEvent
            // Fired when a tile loads.
            this.fire('tileload', {
                tile: tile.el,
                preview: tile.preview,
                coords: coords
            });
        }

        if (this._noTilesToLoad()) {
            this._loading = false;
            // @event load: Event
            // Fired when the grid layer loaded all visible tiles.
            this.fire('load');

            if (L.Browser.ielt9 || !this._map._fadeAnimated) {
                L.Util.requestAnimFrame(this._pruneTiles, this);
            } else {
                // Wait a bit more than 0.2 secs (the duration of the tile fade-in)
                // to trigger a pruning.
                setTimeout(L.bind(this._pruneTiles, this), 250);
            }
        }
    },

    /**
     * В отличие от оригинального метода, здесь url прокидывается параметром
     */
    getTileUrl: function(coords, url) {
        var data = {
            r: L.Browser.retina ? '@2x' : '',
            s: this._getSubdomain(coords),
            x: coords.x,
            y: coords.y,
            z: this._getZoomForUrl()
        };
        if (this._map && !this._map.options.crs.infinite) {
            var invertedY = this._globalTileRange.max.y - coords.y;
            if (this.options.tms) {
                data['y'] = invertedY;
            }
            data['-y'] = invertedY;
        }

        return L.Util.template(url, L.extend(data, this.options));
    },
});


================================================
FILE: src/DGCustomization/src/DGPolyUtil.js
================================================
// from https://github.com/Turfjs/turf-inside/blob/master/index.js
DG.PolyUtil.inside = function(point, polygon, pointReduce) {
    pointReduce = pointReduce || DG.PolyUtil._defaultPointReduce;
    var polys = polygon.coordinates;
    var pt = pointReduce(point);

    // normalize to multipolygon
    if (polygon.type === 'Polygon') {
        polys = [polys];
    }

    var insidePoly = false;
    var i = 0;
    while (i < polys.length && !insidePoly) {
        // check if it is in the outer ring first
        if (this._inRing(pt, polys[i][0], pointReduce)) {
            var inHole = false;
            var k = 1;
            // check for the point in any of the holes
            while (k < polys[i].length && !inHole) {
                if (this._inRing(pt, polys[i][k], pointReduce)) {
                    inHole = true;
                }
                k++;
            }
            if (!inHole)  {
                insidePoly = true;
            }
        }
        i++;
    }
    return insidePoly;
};

// pt is [x,y] and ring is [[x,y], [x,y],..]
DG.PolyUtil._inRing = function(pt, ring, pointReduce) {
    var isInside = false;
    for (var i = 0, j = ring.length - 1; i < ring.length; j = i++) {
        var pi = pointReduce(ring[i]);
        var pj = pointReduce(ring[j]);
        var xi = pi[0], yi = pi[1];
        var xj = pj[0], yj = pj[1];
        var intersect = ((yi > pt[1]) !== (yj > pt[1])) &&
            (pt[0] < (xj - xi) * (pt[1] - yi) / (yj - yi) + xi);

        if (intersect) {
            isInside = !isInside;
        }
    }
    return isInside;
};

DG.PolyUtil._defaultPointReduce = function(point) {
    return point;
};


================================================
FILE: src/DGCustomization/test/CanvasSpec.js
================================================
describe('Canvas', function () {

    var c, map, p2ll, latLngs;

    before(function () {
        c = document.createElement('div');
        c.style.width = '400px';
        c.style.height = '400px';
        c.style.position = 'absolute';
        c.style.top = '0';
        c.style.left = '0';
        document.body.appendChild(c);
        map = new L.Map(c, {preferCanvas: true, zoomControl: false});
        map.setView([0, 0], 6);
        p2ll = function (x, y) {
            return map.layerPointToLatLng([x, y]);
        };
        latLngs = [p2ll(0, 0), p2ll(0, 100), p2ll(100, 100), p2ll(100, 0)];
    });

    // Remove our layers for run test of leflet.
    // Set nonBubblingEvents to [],
    // beacuse in DGCustomization.js we set click is not bubling and test of leflet isn't work
    before(function () {
        map.clearLayers();
        DG.Layer.mergeOptions({
            nonBubblingEvents: []
        });
    });

    after(function () {
        document.body.removeChild(c);
    });

    describe("#events", function () {
        var layer;

        beforeEach(function () {
            layer = L.polygon(latLngs).addTo(map);
        });

        afterEach(function () {
            layer.remove();
        });

        it("should fire event when layer contains mouse", function () {
            var spy = sinon.spy();
            layer.on('click', spy);
            happen.at('click', 50, 50);  // Click on the layer.
            expect(spy.callCount).to.eql(1);
            happen.at('click', 150, 150);  // Click outside layer.
            expect(spy.callCount).to.eql(1);
            layer.off("click", spy);
        });

        it("DOM events propagate from canvas polygon to map", function () {
            var spy = sinon.spy();
            map.on("click", spy);
            happen.at('click', 50, 50);
            expect(spy.callCount).to.eql(1);
            map.off("click", spy);
        });

        it("DOM events fired on canvas polygon can be cancelled before being caught by the map", function () {
            var mapSpy = sinon.spy();
            var layerSpy = sinon.spy();
            map.on("click", mapSpy);
            layer.on("click", L.DomEvent.stopPropagation).on("click", layerSpy);
            happen.at('click', 50, 50);
            expect(layerSpy.callCount).to.eql(1);
            expect(mapSpy.callCount).to.eql(0);
            map.off("click", mapSpy);
            layer.off("click", L.DomEvent.stopPropagation).off("click", layerSpy);
        });

        it("DOM events fired on canvas polygon are propagated only once to the map even when two layers contains the event", function () {
            var spy = sinon.spy();
            var layer2 = L.polygon(latLngs).addTo(map);
            map.on("click", spy);
            happen.at('click', 50, 50);
            expect(spy.callCount).to.eql(1);
            layer2.remove();
            map.off("click", spy);
        });

        it("should fire preclick before click", function () {
            var clickSpy = sinon.spy();
            var preclickSpy = sinon.spy();
            layer.on('click', clickSpy);
            layer.on('preclick', preclickSpy);
            layer.once('preclick', function (e) {
                expect(clickSpy.called).to.be(false);
            });
            happen.at('click', 50, 50);  // Click on the layer.
            expect(clickSpy.callCount).to.eql(1);
            expect(preclickSpy.callCount).to.eql(1);
            happen.at('click', 150, 150);  // Click outside layer.
            expect(clickSpy.callCount).to.eql(1);
            expect(preclickSpy.callCount).to.eql(1);
            layer.off();
        });

        it("should not fire click when dragging the map on top of it", function (done) {
            var downSpy = sinon.spy();
            var clickSpy = sinon.spy();
            var preclickSpy = sinon.spy();
            layer.on('click', clickSpy);
            layer.on('preclick', preclickSpy);
            layer.on('mousedown', downSpy);
            var hand = new Hand({
                timing: 'fastframe',
                onStop: function () {
                    // Prosthetic does not fire a click when we down+up, but it real world
                    // browsers would, so let's simulate it.
                    happen.at('click', 70, 60);
                    expect(downSpy.called).to.be(true);
                    expect(clickSpy.called).to.be(false);
                    expect(preclickSpy.called).to.be(false);
                    layer.off();
                    done();
                }
            });
            var mouse = hand.growFinger('mouse');

            // We move 5 pixels first to overcome the 3-pixel threshold of
            // L.Draggable.
            mouse.moveTo(50, 50, 0)
                .down().moveBy(20, 10, 200).up();
        });

    });

    describe("#events(interactive=false)", function () {
        var layer;

        beforeEach(function () {
            layer = L.polygon(latLngs, {interactive: false}).addTo(map);
        });

        afterEach(function () {
            layer.remove();
        });

        it("should not fire click when not interactive", function () {
            var spy = sinon.spy();
            layer.on('click', spy);
            happen.at('click', 50, 50);  // Click on the layer.
            expect(spy.callCount).to.eql(0);
            happen.at('click', 150, 150);  // Click outside layer.
            expect(spy.callCount).to.eql(0);
            layer.off("click", spy);
        });
    });

    describe('#dashArray', function () {
        it('can add polyline with dashArray', function () {
            var layer = L.polygon(latLngs, {
                dashArray: "5,5"
            }).addTo(map);
        });
        it('can setStyle with dashArray', function () {
            var layer = L.polygon(latLngs).addTo(map);
            layer.setStyle({
                dashArray: "5,5"
            });
        });
    });
});


================================================
FILE: src/DGCustomization/test/DGCustomizationSpec.js
================================================
describe('DGCustomization', function() {
    var mapContainer,
        map;

    before(function () {
        mapContainer = document.createElement('div');
        map = new DG.Map(mapContainer, {
            center: [54.980206086231, 82.898068362003],
            zoom: 15,
            key: window.__karma__.config.secretKey,
        });

        document.body.appendChild(mapContainer);
        map.setLang('ru');
    });

    after(function() {
        map.remove();
        mapContainer.parentElement.removeChild(mapContainer);
        mapContainer = map = null;
    });

    describe('DG.Control', function() {
        it ('change map lang should call _renderTranslation function', function() {
            var control = DG.control(),
                spy = sinon.spy();

            control._renderTranslation = spy;
            map.setLang('en');

            expect(spy).to.be.ok();
        });
    });
});


================================================
FILE: src/DGCustomization/test/DGMap.BaseLayerSpec.js
================================================
describe('DG.TileLayer', function () {
    var mapContainer,
        map;

    before(function () {
        mapContainer = document.createElement('div');
        map = new DG.Map(mapContainer, {
            center: [54.980206086231, 82.898068362003],
            zoom: 15,
            key: window.__karma__.config.secretKey,
        });
    });

    after(function () {
        map.remove();
        mapContainer = map = null;
    });

    describe('check init', function () {
        it('should be map.baseLayer', function () {
            expect(map.baseLayer).to.be.a('object');
        });

        it('should be zIndex 0 on layer container', function () {
            var layerContainer = map.baseLayer._container;

            expect(Number(layerContainer.style.zIndex)).to.be(0);
        });
    });
});


================================================
FILE: src/DGCustomization/test/DGMapSpec.js
================================================
describe('DGMap', function () {
    var mapContainer,
        center = [54.980206086231, 82.898068362003],
        map,
        newCenter = [55.01749277152058, 82.92145729064943],
        moveStartSpy,
        moveEndSpy;

    before(function () {
        mapContainer = document.createElement('div');
        map = new DG.Map(mapContainer, {
            center: center,
            zoom: 15,
            key: window.__karma__.config.secretKey,
        });
        document.body.appendChild(mapContainer);
        map.setLang('ru');
        map.invalidateSize();
    });

    after(function () {
        mapContainer.parentElement.removeChild(mapContainer);
        mapContainer = map = center = newCenter = moveStartSpy = moveEndSpy = null;
    });

    describe('#setView', function () {
        describe('change center without animate', function () {
            before(function() {
                map.setView(center, 13, {animate: false});

                moveStartSpy = sinon.spy();
                moveEndSpy = sinon.spy();

                map.on('movestart', moveStartSpy);
                map.on('moveend', moveEndSpy);

                map.setView(newCenter, 13, {animate: false});
            });

            after(function () {
                map.off('movestart', moveStartSpy);
                map.off('moveend', moveEndSpy);
            });

            it('should change center', function () {
                expect(DG.latLng(newCenter)).to.nearLatLng(map.getCenter());
            });

            it('should fire movestart event', function () {
                expect(moveStartSpy.calledOnce).to.be.ok();
            });

            it('shouldn fire moveend event while animate', function () {
                expect(moveEndSpy.calledOnce).to.be.ok();
            });
        });

        describe('change center with animate = true', function () {
            before(function () {
                map.setView(center, 13, {animate: false});

                moveStartSpy = sinon.spy();
                moveEndSpy = sinon.spy();

                map.on('movestart', moveStartSpy);
                map.on('moveend', moveEndSpy);

                map.setView(newCenter, 13, {animate: true});
            });

            after(function () {
                map.off('movestart', moveStartSpy);
                map.off('moveend', moveEndSpy);
            });

            it('should fire movestart event before animate', function () {
                expect(moveStartSpy.calledOnce).to.be.ok();
            });

            it('shouldn\'t fire moveend event while animate', function () {
                expect(moveEndSpy.calledOnce).not.be.ok();
            });
        });
    });

    describe('#panBy', function () {
        it('should set zoom to 13 after panBy to place without project', function () {
            map.setView([55.005582426668404, 82.93081283569337], 18, {animate: false});
            map.panBy([1e15, 0]);
            expect(map.getZoom()).to.be(16);
        });
    });

    describe('#getBoundsZoom', function () {
        it('should return 16', function () {
            // тут должен быть баунд территории, которая не содержить проекта,
            // при этом такой, что при призуме к нему будет зум > 16
            var sw = DG.latLng(67.521706581271, 97.5729274749756),
                ne = DG.latLng(67.52332271114147, 97.57734775543214),
                b = DG.latLngBounds(sw, ne);

            expect(map.getBoundsZoom(b)).to.be(16); // 16 - это максимальный зум карты в месте где нет проекта
        });
    });
});


================================================
FILE: src/DGCustomization/test/GridLayerSpec.js
================================================

describe('GridLayer', function () {

    var div, map;

    beforeEach(function () {
        div = document.createElement('div');
        div.style.width = '800px';
        div.style.height = '600px';
        div.style.visibility = 'hidden';

        document.body.appendChild(div);

        map = L.map(div);
    });

    afterEach(function () {
        document.body.removeChild(div);
    });

    describe('#redraw', function () {
        it('can be called before map.setView', function () {
            var grid = L.gridLayer().addTo(map);
            expect(grid.redraw()).to.equal(grid);
        });
    });

    describe('#setOpacity', function () {
        it('can be called before map.setView', function () {
            var grid = L.gridLayer().addTo(map);
            expect(grid.setOpacity(0.5)).to.equal(grid);
        });

        it('works when map has fadeAnimated=false (IE8 is exempt)', function (done) {
            map.remove();
            map = L.map(div, {fadeAnimation: false}).setView([0, 0], 0);

            var grid = L.gridLayer().setOpacity(0.5).addTo(map);
            grid.on('load', function () {
                expect(grid._container.style.opacity).to.equal('0.5');
                done();
            });
        });
    });

    it('positions tiles correctly with wrapping and bounding', function () {

        map.setView([0, 0], 1);

        var tiles = [];

        var grid = L.gridLayer();
        grid.createTile = function (coords) {
            var tile = document.createElement('div');
            tiles.push({coords: coords, tile: tile});
            return tile;
        };

        map.addLayer(grid);

        var loaded = {};

        for (var i = 0; i < tiles.length; i++) {
            var coords = tiles[i].coords,
                pos = L.DomUtil.getPosition(tiles[i].tile);

            loaded[pos.x + ':' + pos.y] = [coords.x, coords.y];
        }

        expect(loaded).to.eql({
            '144:0': [0, 0],
            '400:0': [1, 0],
            '144:256': [0, 1],
            '400:256': [1, 1],
            '-112:0': [1, 0],
            '656:0': [0, 0],
            '-112:256': [1, 1],
            '656:256': [0, 1]
        });
    });

    describe('tile pyramid', function () {
        var clock;

        beforeEach(function () {
            clock = sinon.useFakeTimers();
        });

        afterEach(function () {
            clock.restore();
        });

        it('removes tiles for unused zoom levels', function (done) {
            map.remove();
            map = L.map(div, {fadeAnimation: false});
            map.setView([0, 0], 1);

            var grid = L.gridLayer();
            var tiles = {};

            grid.createTile = function (coords) {
                tiles[grid._tileCoordsToKey(coords)] = true;
                return document.createElement('div');
            };

            grid.on('tileunload', function (e) {
                delete tiles[grid._tileCoordsToKey(e.coords)];
                if (Object.keys(tiles).length === 1) {
                    var tunKey = Object.keys(tiles)[0];
                    expect(tunKey === '0:0:0' || tunKey === '1:1:1').to.be.ok();
                    done();
                }
            });

            map.addLayer(grid);
            map.setZoom(0, {animate: false});
            clock.tick(250);
        });
    });

    describe('#createTile', function () {

        beforeEach(function () {
            // Simpler sizes to test.
            div.style.width = '512px';
            div.style.height = '512px';
        });

        afterEach(function () {
            div.style.width = '800px';
            div.style.height = '600px';
        });

        // Passes on Firefox, but fails on phantomJS: done is never called.
        xit('only creates tiles for visible area on zoom in', function (done) {
            map.remove();
            map = L.map(div);
            map.setView([0, 0], 10);

            var grid = L.gridLayer(),
                count = 0,
                loadCount = 0;
            grid.createTile = function (coords) {
                count++;
                return document.createElement('div');
            };
            var onLoad = function (e) {
                expect(count).to.eql(4);
                count = 0;
                loadCount++;
                if (loadCount === 1) {  // On layer add.
                    map.zoomIn();
                } else {  // On zoom in.
                    done();
                }
            };
            grid.on('load', onLoad);
            map.addLayer(grid);
        });

    });

    describe("#onAdd", function () {
        it('is called after zoomend on first map load', function () {
            var layer = L.gridLayer().addTo(map);

            var onAdd = layer.onAdd,
                onAddSpy = sinon.spy();
            layer.onAdd = function () {
                onAdd.apply(this, arguments);
                onAddSpy();
            };

            var onReset = sinon.spy();
            map.on('zoomend', onReset);
            map.setView([0, 0], 0);

            expect(onReset.calledBefore(onAddSpy)).to.be.ok();
        });
    });

    describe("#getMaxZoom, #getMinZoom", function () {

        // Skip because we have base layer with greater zooms.
        describe.skip("when a tilelayer is added to a map with no other layers", function () {
            it("has the same zoomlevels as the tilelayer", function () {
                var maxZoom = 10,
                    minZoom = 5;

                map.setView([0, 0], 1);

                L.gridLayer({
                    maxZoom: maxZoom,
                    minZoom: minZoom
                }).addTo(map);

                expect(map.getMaxZoom()).to.be(maxZoom);
                expect(map.getMinZoom()).to.be(minZoom);
            });
        });

        describe("accessing a tilelayer's properties", function () {
            it('provides a container', function () {
                map.setView([0, 0], 1);

                var layer = L.gridLayer().addTo(map);
                expect(layer.getContainer()).to.be.ok();
            });
        });

        // Skip because we have base layer with greater zooms.
        describe.skip("when a tilelayer is added to a map that already has a tilelayer", function () {
            it("has its zoomlevels updated to fit the new layer", function () {
                map.setView([0, 0], 1);

                L.gridLayer({minZoom: 10, maxZoom: 15}).addTo(map);
                expect(map.getMinZoom()).to.be(10);
                expect(map.getMaxZoom()).to.be(15);

                L.gridLayer({minZoom: 5, maxZoom: 10}).addTo(map);
                expect(map.getMinZoom()).to.be(5);  // changed
                expect(map.getMaxZoom()).to.be(15); // unchanged

                L.gridLayer({minZoom: 10, maxZoom: 20}).addTo(map);
                expect(map.getMinZoom()).to.be(5);  // unchanged
                expect(map.getMaxZoom()).to.be(20); // changed


                L.gridLayer({minZoom: 0, maxZoom: 25}).addTo(map);
                expect(map.getMinZoom()).to.be(0); // changed
                expect(map.getMaxZoom()).to.be(25); // changed
            });
        });
        describe("when a tilelayer is removed from a map", function () {
            it("has its zoomlevels updated to only fit the layers it currently has", function () {
                var tiles = [
                    L.gridLayer({minZoom: 10, maxZoom: 15}).addTo(map),
                    L.gridLayer({minZoom: 5, maxZoom: 10}).addTo(map),
                    L.gridLayer({minZoom: 10, maxZoom: 20}).addTo(map),
                    L.gridLayer({minZoom: 0, maxZoom: 25}).addTo(map)
                ];
                map.whenReady(function () {
                    expect(map.getMinZoom()).to.be(0);
                    expect(map.getMaxZoom()).to.be(25);

                    map.removeLayer(tiles[0]);
                    expect(map.getMinZoom()).to.be(0);
                    expect(map.getMaxZoom()).to.be(25);

                    map.removeLayer(tiles[3]);
                    expect(map.getMinZoom()).to.be(5);
                    expect(map.getMaxZoom()).to.be(20);

                    map.removeLayer(tiles[2]);
                    expect(map.getMinZoom()).to.be(5);
                    expect(map.getMaxZoom()).to.be(10);

                    map.removeLayer(tiles[1]);
                    expect(map.getMinZoom()).to.be(0);
                    expect(map.getMaxZoom()).to.be(Infinity);
                });
            });
        });
    });

    describe("number of 256px tiles loaded in synchronous non-animated grid @800x600px", function () {
        var clock, grid, counts;

        beforeEach(function () {
            clock = sinon.useFakeTimers();

            grid = L.gridLayer({
                attribution: 'Grid Layer',
                tileSize: L.point(256, 256)
            });

            grid.createTile = function (coords) {
                var tile = document.createElement('div');
                tile.innerHTML = [coords.x, coords.y, coords.z].join(', ');
                tile.style.border = '2px solid red';
                return tile;
            };

            counts = {
                tileload: 0,
                tileerror: 0,
                tileloadstart: 0,
                tileunload: 0
            };

            grid.on('tileload tileunload tileerror tileloadstart', function (ev) {
// 				console.log(ev.type);
                counts[ev.type]++;
            });
// 			grid.on('tileunload', function (ev) {
// 				console.log(ev.type, ev.coords, counts);
// 			});

            map.options.fadeAnimation = false;
            map.options.zoomAnimation = false;
        });

        afterEach(function () {
            clock.restore();
            grid.off();
            grid = undefined;
            counts = undefined;
        });

        it("Loads 8 tiles zoom 1", function (done) {

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(8);
                expect(counts.tileload).to.be(8);
                expect(counts.tileunload).to.be(0);
                done();
            });

            map.addLayer(grid).setView([0, 0], 1);
            clock.tick(250);
        });

        it("Loads 5 tiles zoom 0", function (done) {

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(5);
                expect(counts.tileload).to.be(5);
                expect(counts.tileunload).to.be(0);
                done();
            });

            map.addLayer(grid).setView([0, 0], 0);
            clock.tick(250);
        });

        it("Loads 16 tiles zoom 10", function (done) {

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(16);
                expect(counts.tileload).to.be(16);
                expect(counts.tileunload).to.be(0);
                grid.off();

                done();
            });

            map.addLayer(grid).setView([0, 0], 10);
            clock.tick(250);
        });

        it("Loads 32, unloads 16 tiles zooming in 10-11", function (done) {

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(16);
                expect(counts.tileload).to.be(16);
                expect(counts.tileunload).to.be(0);
                grid.off('load');

                grid.on('load', function () {
                    expect(counts.tileloadstart).to.be(32);
                    expect(counts.tileload).to.be(32);
                    expect(counts.tileunload).to.be(16);
                    done();
                });

                map.setZoom(11, {animate: false});
                clock.tick(250);
            });


            map.addLayer(grid).setView([0, 0], 10);
            clock.tick(250);
        });

        it("Loads 32, unloads 16 tiles zooming out 11-10", function (done) {

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(16);
                expect(counts.tileload).to.be(16);
                expect(counts.tileunload).to.be(0);
                grid.off('load');

                grid.on('load', function () {
                    expect(counts.tileloadstart).to.be(32);
                    expect(counts.tileload).to.be(32);
                    expect(counts.tileunload).to.be(16);
                    done();
                });

                map.setZoom(10, {animate: false});
                clock.tick(250);
            });


            map.addLayer(grid).setView([0, 0], 11);
            clock.tick(250);
        });


        it("Loads 32, unloads 16 tiles zooming out 18-10", function (done) {

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(16);
                expect(counts.tileload).to.be(16);
                expect(counts.tileunload).to.be(0);
                grid.off('load');

                grid.on('load', function () {
                    expect(counts.tileloadstart).to.be(32);
                    expect(counts.tileload).to.be(32);
                    expect(counts.tileunload).to.be(16);
                    done();
                });

                map.setZoom(10, {animate: false});
                clock.tick(250);
            });


            map.addLayer(grid).setView([0, 0], 18);
            clock.tick(250);
        });

    });

    describe("number of 256px tiles loaded in synchronous animated grid @800x600px", function () {

        var clock, grid, counts;

        beforeEach(function () {
            clock = sinon.useFakeTimers();

            grid = L.gridLayer({
                attribution: 'Grid Layer',
                tileSize: L.point(256, 256)
            });

            grid.createTile = function (coords) {
                var tile = document.createElement('div');
                tile.innerHTML = [coords.x, coords.y, coords.z].join(', ');
                tile.style.border = '2px solid red';
                return tile;
            };

            counts = {
                tileload: 0,
                tileerror: 0,
                tileloadstart: 0,
                tileunload: 0
            };

            grid.on('tileload tileunload tileerror tileloadstart', function (ev) {
                counts[ev.type]++;
            });
        });

        afterEach(function () {
            clock.restore();
            grid.off();
            grid = undefined;
            counts = undefined;
        });

        // Debug helper
        function logTiles(ev) {
            var pending = 0;
            for (var key in grid._tiles) {
                if (!grid._tiles[key].loaded) { pending++; }
            }
            console.log(ev.type + ': ', ev.coords, grid._loading, counts, ' pending: ', pending);
        }


        // animationFrame helper, just runs requestAnimFrame() a given number of times
        function runFrames(n) {
            return _runFrames(n)();
        }

        function _runFrames(n) {
            if (n) {
                return function () {
                    clock.tick(40); // 40msec/frame ~= 25fps
                    map.fire('_frame');
                    L.Util.requestAnimFrame(_runFrames(n - 1));
                };
            } else {
                return L.Util.falseFn;
            }
        }

        // NOTE: This test has different behaviour in PhantomJS and graphical
        // browsers due to CSS animations!
        it.skipInPhantom("Loads 32, unloads 16 tiles zooming in 10-11", function (done) {

// 			grid.on('tileload tileunload tileloadstart load', logTiles);

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(16);
                expect(counts.tileload).to.be(16);
                expect(counts.tileunload).to.be(0);
                grid.off('load');

// 				grid.on('load', logTiles);
                grid.on('load', function () {

                    // We're one frame into the zoom animation, there are
                    // 16 tiles for z10 plus 16 tiles for z11 covering the
                    // bounds at the *end* of the zoom-*in* anim
                    expect(counts.tileloadstart).to.be(32);
                    expect(counts.tileload).to.be(32);
                    expect(counts.tileunload).to.be(0);

                    // Wait > 250msec for the tile fade-in animation to complete,
                    // which triggers the tile pruning
                    clock.tick(300);

                    // After the zoom-in, the 'outside' 12 tiles (not the 4
                    // at the center, still in bounds) have been unloaded.
                    expect(counts.tileunload).to.be(12);

                    L.Util.requestAnimFrame(function () {
                        expect(counts.tileloadstart).to.be(32);
                        expect(counts.tileload).to.be(32);
                        expect(counts.tileunload).to.be(16);
                        done();
                    });
                });

                map.setZoom(11, {animate: true});
                clock.tick(250);
            });

            map.addLayer(grid).setView([0, 0], 10);
            clock.tick(250);
        });

        it("Loads 32, unloads 16 tiles zooming in 10-18", function (done) {
            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(16);
                expect(counts.tileload).to.be(16);
                expect(counts.tileunload).to.be(0);
                grid.off('load');

                grid.on('load', function () {

                    // In this particular scenario, the tile unloads happen in the
                    // next render frame after the grid's 'load' event.
                    L.Util.requestAnimFrame(function () {
                        expect(counts.tileloadstart).to.be(32);
                        expect(counts.tileload).to.be(32);
                        expect(counts.tileunload).to.be(16);
                        done();
                    });
                });

                map.setZoom(18, {animate: true});
                clock.tick(250);
            });

            map.addLayer(grid).setView([0, 0], 10);
            clock.tick(250);
        });

        // NOTE: This test has different behaviour in PhantomJS and graphical
        // browsers due to CSS animations!
        it.skipInPhantom("Loads 32, unloads 16 tiles zooming out 11-10", function (done) {

// 			grid.on('tileload tileunload load', logTiles);

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(16);
                expect(counts.tileload).to.be(16);
                expect(counts.tileunload).to.be(0);
                grid.off('load');

// 				grid.on('load', logTiles);
                grid.on('load', function () {

                    grid.off('load');
// 					grid.on('load', logTiles);

                    // We're one frame into the zoom animation, there are
                    // 16 tiles for z11 plus 4 tiles for z10 covering the
                    // bounds at the *beginning* of the zoom-*out* anim
                    expect(counts.tileloadstart).to.be(20);
                    expect(counts.tileload).to.be(20);
                    expect(counts.tileunload).to.be(0);


                    // Wait > 250msec for the tile fade-in animation to complete,
                    // which triggers the tile pruning
                    clock.tick(300);
                    L.Util.requestAnimFrame(function () {
                        expect(counts.tileunload).to.be(16);

                        // The next 'load' event happens when the zoom anim is
                        // complete, and triggers loading of all the z10 tiles.
                        grid.on('load', function () {
                            expect(counts.tileloadstart).to.be(32);
                            expect(counts.tileload).to.be(32);
                            done();
                        });

                    });
                });

                map.setZoom(10, {animate: true});
                clock.tick(250);
            });

            map.addLayer(grid).setView([0, 0], 11);
            clock.tick(250);
        });

        it("Loads 32, unloads 16 tiles zooming out 18-10", function (done) {

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(16);
                expect(counts.tileload).to.be(16);
                expect(counts.tileunload).to.be(0);
                grid.off('load');

                grid.on('load', function () {

                    // In this particular scenario, the tile unloads happen in the
                    // next render frame after the grid's 'load' event.
                    L.Util.requestAnimFrame(function () {
                        expect(counts.tileloadstart).to.be(32);
                        expect(counts.tileload).to.be(32);
                        expect(counts.tileunload).to.be(16);
                        done();
                    });
                });

                map.setZoom(10, {animate: true});
                clock.tick(250);
            });

            map.addLayer(grid).setView([0, 0], 18);
            clock.tick(250);
        });

        // NOTE: This test has different behaviour in PhantomJS and graphical
        // browsers due to CSS animations!
        it.skipInPhantom("Loads 290, unloads 275 tiles on MAD-TRD flyTo()", function (done) {

            this.timeout(10000); // This test takes longer than usual due to frames

            var mad = [40.40, -3.7], trd = [63.41, 10.41];

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(12);
                expect(counts.tileload).to.be(12);
                expect(counts.tileunload).to.be(0);
                grid.off('load');

                map.on('zoomend', function () {
                    expect(counts.tileloadstart).to.be(290);
                    expect(counts.tileunload).to.be(275);
                    expect(counts.tileload).to.be(290);
                    expect(grid._container.querySelectorAll('div').length).to.be(16);	// 15 + container
                    done();
                });

                map.flyTo(trd, 12, {animate: true});

// 				map.on('_frame', function () {
// 					console.log('frame', counts);
// 				});

                runFrames(500);
            });

            map.addLayer(grid).setView(mad, 12);
            clock.tick(250);
        });

    });

    describe("configurable tile pruning", function () {
        var clock, grid, counts;

        beforeEach(function () {
            clock = sinon.useFakeTimers();

            grid = L.gridLayer({
                attribution: 'Grid Layer',
                tileSize: L.point(256, 256)
            });

            grid.createTile = function (coords) {
                var tile = document.createElement('div');
                tile.innerHTML = [coords.x, coords.y, coords.z].join(', ');
                tile.style.border = '2px solid red';
                return tile;
            };

            counts = {
                tileload: 0,
                tileerror: 0,
                tileloadstart: 0,
                tileunload: 0
            };

            grid.on('tileload tileunload tileerror tileloadstart', function (ev) {
// 				console.log(ev.type);
                counts[ev.type]++;
            });
// 			grid.on('tileunload', function (ev) {
// 				console.log(ev.type, ev.coords, counts);
// 			});

            map.options.fadeAnimation = false;
            map.options.zoomAnimation = false;
        });

        afterEach(function () {
            clock.restore();
            grid.off();
            grid = undefined;
            counts = undefined;
        });

        it("Loads map, moves forth by 512 px, keepBuffer = 0", function (done) {

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(16);
                expect(counts.tileload).to.be(16);
                expect(counts.tileunload).to.be(0);
                grid.off('load');

                grid.on('load', function () {
                    expect(counts.tileloadstart).to.be(28);
                    expect(counts.tileload).to.be(28);
                    expect(counts.tileunload).to.be(12);
                    done();
                });

                map.panBy([512, 512], {animate: false});
                clock.tick(250);
            });

            grid.options.keepBuffer = 0;

            map.addLayer(grid).setView([0, 0], 10);
            clock.tick(250);
        });

        it("Loads map, moves forth and back by 512 px, keepBuffer = 0", function (done) {

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(16);
                expect(counts.tileload).to.be(16);
                expect(counts.tileunload).to.be(0);
                grid.off('load');

                grid.on('load', function () {
                    expect(counts.tileloadstart).to.be(28);
                    expect(counts.tileload).to.be(28);
                    expect(counts.tileunload).to.be(12);

                    grid.off('load');
                    grid.on('load', function () {
                        expect(counts.tileloadstart).to.be(40);
                        expect(counts.tileload).to.be(40);
                        expect(counts.tileunload).to.be(24);
                        done();
                    });

                    map.panBy([-512, -512], {animate: false});
                    clock.tick(250);
                });

                map.panBy([512, 512], {animate: false});
                clock.tick(250);
            });

            grid.options.keepBuffer = 0;

            map.addLayer(grid).setView([0, 0], 10);
            clock.tick(250);
        });

        it("Loads map, moves forth and back by 512 px, default keepBuffer", function (done) {

            var spy = sinon.spy();

            grid.on('load', function () {
                expect(counts.tileloadstart).to.be(16);
                expect(counts.tileload).to.be(16);
                expect(counts.tileunload).to.be(0);
                grid.off('load');

                grid.on('load', function () {
                    expect(counts.tileloadstart).to.be(28);
                    expect(counts.tileload).to.be(28);
                    expect(counts.tileunload).to.be(0);
                    grid.off('load');

                    grid.addEventListener('load', spy);

                    map.panBy([-512, -512], {animate: false});
                    clock.tick(250);

                    expect(spy.called).to.be(false);
                    done();
                });

                map.panBy([512, 512], {animate: false});
                clock.tick(250);
            });

            map.addLayer(grid).setView([0, 0], 10);
            clock.tick(250);
        });
    });
});


================================================
FILE: src/DGCustomization/test/Map.DragSpec.js
================================================
describe("Map.Drag", function () {
	describe("#addHook", function () {
		it("calls the map with dragging enabled", function () {
			var container = document.createElement('div');
			var map = new L.Map(container, {
				dragging: true
			});

			expect(map.dragging.enabled()).to.be(true);
			map.setView([0, 0], 0);
			expect(map.dragging.enabled()).to.be(true);
		});
		it("calls the map with dragging and worldCopyJump enabled", function () {
			var container = document.createElement('div');
			var map = new L.Map(container, {
				dragging: true,
				worldCopyJump: true
			});

			expect(map.dragging.enabled()).to.be(true);
			map.setView([0, 0], 0);
			expect(map.dragging.enabled()).to.be(true);
		});
		it("calls the map with dragging disabled and worldCopyJump enabled; " +
			"enables dragging after setting center and zoom", function () {
			var container = document.createElement('div');
			var map = new L.Map(container, {
				dragging: false,
				worldCopyJump: true
			});

			expect(map.dragging.enabled()).to.be(false);
			map.setView([0, 0], 0);
			map.dragging.enable();
			expect(map.dragging.enabled()).to.be(true);
		});
	});


	describe("mouse events", function () {
		it("change the center of the map", function (done) {
			var container = document.createElement('div');
			container.style.width = container.style.height = '600px';
			container.style.top = container.style.left = 0;
			container.style.position = 'absolute';
			// 			container.style.background = '#808080';

			document.body.appendChild(container);

			var map = new L.Map(container, {
				dragging: true,
				inertia: false
			});
			map.setView([0, 0], 1);

			var hand = new Hand({
				timing: 'fastframe',
				onStop: function () {
					var center = map.getCenter();
					var zoom = map.getZoom();
					document.body.removeChild(container);
					expect(center.lat).to.be.within(21.9430, 21.9431);
					expect(center.lng).to.be(-180);
					expect(zoom).to.be(1);

					done();
				}
			});
			var mouse = hand.growFinger('mouse');

			// We move 5 pixels first to overcome the 3-pixel threshold of
			// L.Draggable.
			mouse.wait(100).moveTo(200, 200, 0)
				.down().moveBy(5, 0, 20).moveBy(256, 32, 200).up();
		});

		it("does not change the center of the map when mouse is moved less than the drag threshold", function (done) {
			var container = document.createElement('div');
			container.style.width = container.style.height = '600px';
			container.style.top = container.style.left = 0;
			container.style.position = 'absolute';

			document.body.appendChild(container);

			var map = new L.Map(container, {
				dragging: true,
				inertia: false
			});

			var originalCenter = L.latLng(0, 0);
			map.setView(originalCenter, 1);

			var spy = sinon.spy();
			map.on('drag', spy);

			var hand = new Hand({
				timing: 'fastframe',
				onStop: function () {
					var center = map.getCenter();
					var zoom = map.getZoom();
					document.body.removeChild(container);
					expect(center).to.eql(originalCenter); // Expect center point to be the same as before the click
					expect(spy.callCount).to.eql(0); // No drag event should have been fired.
					expect(zoom).to.be(1);

					done();
				}
			});
			var mouse = hand.growFinger('mouse');

			// We move 2 pixels to stay below the default 3-pixel threshold of
			// L.Draggable. This should result in a click and not a drag.
			mouse.wait(100).moveTo(200, 200, 0)
				.down().moveBy(1, 0, 20).moveBy(1, 0, 200).up();
		});

		it("does not change the center of the map when drag is disabled on click", function (done) {
			var container = document.createElement('div');
			container.style.width = container.style.height = '600px';
			container.style.top = container.style.left = 0;
			container.style.position = 'absolute';

			document.body.appendChild(container);

			var map = new L.Map(container, {
				dragging: true,
				inertia: false
			});
			var originalCenter = L.latLng(0, 0);
			map.setView(originalCenter, 1);

			map.on('mousedown', function () {
				map.dragging.disable();
			});
			var spy = sinon.spy();
			map.on('drag', spy);

			var hand = new Hand({
				timing: 'fastframe',
				onStop: function () {
					var center = map.getCenter();
					var zoom = map.getZoom();
					document.body.removeChild(container);
					expect(center).to.eql(originalCenter); // Expect center point to be the same as before the click
					expect(spy.callCount).to.eql(0); // No drag event should have been fired.
					expect(zoom).to.be(1);

					done();
				}
			});
			var mouse = hand.growFinger('mouse');

			// We move 5 pixels first to overcome the 3-pixel threshold of
			// L.Draggable.
			mouse.wait(100).moveTo(200, 200, 0)
				.down().moveBy(5, 0, 20).moveBy(256, 32, 200).up();
		});
	});

	describe("touch events", function () {
		it.skipIfNotTouch("change the center of the map", function (done) {
			var container = document.createElement('div');
			container.style.width = container.style.height = '600px';
			container.style.top = container.style.left = 0;
			container.style.position = 'absolute';
			// 			container.style.background = '#808080';

			document.body.appendChild(container);

			var map = new L.Map(container, {
				dragging: true,
				inertia: false
			});
			map.setView([0, 0], 1);

			var hand = new Hand({
				timing: 'fastframe',
				onStop: function () {
					var center = map.getCenter();
					var zoom = map.getZoom();
					document.body.removeChild(container);
					expect(center.lat).to.be.within(21.9430, 21.9431);
					expect(center.lng).to.be(-180);
					expect(zoom).to.be(1);

					done();
				}
			});
			var toucher = hand.growFinger('touch');

			// We move 5 pixels first to overcome the 3-pixel threshold of
			// L.Draggable.
			toucher.wait(100).moveTo(200, 200, 0)
				.down().moveBy(5, 0, 20).moveBy(256, 32, 200).up();
		});

		it("does not change the center of the map when finger is moved less than the drag threshold", function (done) {
			var container = document.createElement('div');
			container.style.width = container.style.height = '600px';
			container.style.top = container.style.left = 0;
			container.style.position = 'absolute';

			document.body.appendChild(container);

			var map = new L.Map(container, {
				dragging: true,
				inertia: false
			});

			var originalCenter = L.latLng(0, 0);
			map.setView(originalCenter, 1);

			var spy = sinon.spy();
			map.on('drag', spy);

			var hand = new Hand({
				timing: 'fastframe',
				onStop: function () {
					var center = map.getCenter();
					var zoom = map.getZoom();
					document.body.removeChild(container);
					expect(center).to.eql(originalCenter); // Expect center point to be the same as before the click
					expect(spy.callCount).to.eql(0); // No drag event should have been fired.
					expect(zoom).to.be(1);

					done();
				}
			});

			var toucher = hand.growFinger('touch');

			// We move 2 pixels to stay below the default 3-pixel threshold of
			// L.Draggable. This should result in a click and not a drag.
			toucher.wait(100).moveTo(200, 200, 0)
				.down().moveBy(1, 0, 20).moveBy(1, 0, 200).up();
		});

		it.skipIfNotTouch('reset itself after touchend', function (done) {

			var container = document.createElement('div');
			container.style.width = container.style.height = '600px';
			container.style.top = container.style.left = 0;
			container.style.position = 'absolute';
			document.body.appendChild(container);
			var map = new L.Map(container, {
				dragging: true,
				inertia: false,
				zoomAnimation: false	// If true, the test has to wait extra 250msec
			});
			map.setView([0, 0], 1);

			// Change default events order to make the tap comming before the touchzoom.
			// See #4315
			map.dragging.disable();
			map.dragging.enable();

			var center = map.getCenter(),
			zoom = map.getZoom();


			var mouseHand = new Hand({
				timing: 'fastframe',
				onStop: function () {
					document.body.removeChild(container);
					expect(map.getCenter().lat).to.be(center.lat);
					expect(map.getCenter().lng).to.be.within(center.lng - 0.05, center.lng + 0.05);
					expect(map.getZoom()).to.eql(zoom);

					done();
				}
			});
			var mouse = mouseHand.growFinger('mouse');
			var hand = new Hand({
				timing: 'fastframe',
				onStop: function () {
					expect(map.getCenter()).not.to.eql(center);
					expect(map.getZoom()).not.to.eql(zoom);
					center = map.getCenter();
					zoom = map.getZoom();
					mouse.moveTo(220, 220, 0).moveBy(200, 0, 2000);
				}
			});

			var f1 = hand.growFinger('touch');
			var f2 = hand.growFinger('touch');

			hand.sync(5);
			f1.wait(100).moveTo(275, 300, 0)
				.down().moveBy(-200, 0, 1000).up(200);
			// This finger should touch me map after the other one.
			f2.wait(110).moveTo(325, 300, 0)
				.down().moveBy(210, 0, 1000).up(200);

		});

	});

});


================================================
FILE: src/DGCustomization/test/MapSpec.js
================================================
describe("Map", function () {
    var map,
        spy;
    beforeEach(function () {
        map = L.map(document.createElement('div'));
    });

    // Remove our layers.
    beforeEach(function () {
        map.clearLayers();
    });

    describe("#remove", function () {
        it("fires an unload event if loaded", function () {
            var container = document.createElement('div'),
                map = new L.Map(container).setView([0, 0], 0),
                spy = sinon.spy();
            map.on('unload', spy);
            map.remove();
            expect(spy.called).to.be.ok();
        });

        it("fires no unload event if not loaded", function () {
            var container = document.createElement('div'),
                map = new L.Map(container),
                spy = sinon.spy();
            map.on('unload', spy);
            map.remove();
            expect(spy.called).not.to.be.ok();
        });

        describe("corner case checking", function () {
            it("throws an exception upon reinitialization", function () {
                var container = document.createElement('div'),
                    map = new L.Map(container);
                expect(function () {
                    L.map(container);
                }).to.throwException(function (e) {
                    expect(e.message).to.eql("Map container is already initialized.");
                });
                map.remove();
            });

            it("throws an exception if a container is not found", function () {
                expect(function () {
                    L.map('nonexistentdivelement');
                }).to.throwException(function (e) {
                    expect(e.message).to.eql("Map container not found.");
                });
                map.remove();
            });
        });

        it("undefines container._leaflet", function () {
            var container = document.createElement('div'),
                map = new L.Map(container);
            map.remove();
            expect(container._leaflet).to.be(undefined);
        });

        it("unbinds events", function () {
            var container = document.createElement('div'),
                map = new L.Map(container).setView([0, 0], 1),
                spy = sinon.spy();

            map.on('click dblclick mousedown mouseup mousemove', spy);
            map.remove();

            happen.click(container);
            happen.dblclick(container);
            happen.mousedown(container);
            happen.mouseup(container);
            happen.mousemove(container);

            expect(spy.called).to.not.be.ok();
        });
    });

    describe('#getCenter', function () {
        it('throws if not set before', function () {
            expect(function () {
                map.getCenter();
            }).to.throwError();
        });

        it('returns a precise center when zoomed in after being set (#426)', function () {
            var center = L.latLng(10, 10);
            map.setView(center, 1);
            map.setZoom(19);
            expect(map.getCenter()).to.eql(center);
        });

        it('returns correct center after invalidateSize (#1919)', function () {
            map.setView(L.latLng(10, 10), 1);
            map.invalidateSize();
            expect(map.getCenter()).not.to.eql(L.latLng(10, 10));
        });
    });

    describe("#whenReady", function () {
        describe("when the map has not yet been loaded", function () {
            it("calls the callback when the map is loaded", function () {
                var spy = sinon.spy();
                map.whenReady(spy);
                expect(spy.called).to.not.be.ok();

                map.setView([0, 0], 1);
                expect(spy.called).to.be.ok();
            });
        });

        describe("when the map has already been loaded", function () {
            it("calls the callback immediately", function () {
                var spy = sinon.spy();
                map.setView([0, 0], 1);
                map.whenReady(spy);

                expect(spy.called).to.be.ok();
            });
        });
    });

    describe("#setView", function () {
        it("sets the view of the map", function () {
            expect(map.setView([51.505, -0.09], 13)).to.be(map);
            expect(map.getZoom()).to.be(13);
            expect(map.getCenter().distanceTo([51.505, -0.09])).to.be.lessThan(5);
        });

        it("can be passed without a zoom specified", function () {
            map.setZoom(13);
            expect(map.setView([51.605, -0.11])).to.be(map);
            expect(map.getZoom()).to.be(13);
            expect(map.getCenter().distanceTo([51.605, -0.11])).to.be.lessThan(5);
        });

        // Skip because we have custom logic for maxZoom. Function setZoom is overridden in DGMap.js
        it.skip("limits initial zoom when no zoom specified", function () {
            map.options.maxZoom = 20;
            map.setZoom(100);
            expect(map.setView([51.605, -0.11])).to.be(map);
            expect(map.getZoom()).to.be(20);
            expect(map.getCenter().distanceTo([51.605, -0.11])).to.be.lessThan(5);
        });

        it("defaults to zoom passed as map option", function () {
            map = L.map(document.createElement('div'), {zoom: 13});
            expect(map.setView([51.605, -0.11])).to.be(map);
            expect(map.getZoom()).to.be(13);
        });

        it("passes duration option to panBy", function () {
            map = L.map(document.createElement('div'), {zoom: 13, center: [0, 0]});
            map.panBy = sinon.spy();
            map.setView([51.605, -0.11], 13, {animate: true, duration: 13});
            expect(map.panBy.callCount).to.eql(1);
            expect(map.panBy.args[0][1].duration).to.eql(13);
        });
    });

    describe("#getBounds", function () {
        it("is safe to call from within a moveend callback during initial load (#1027)", function () {
            map.on("moveend", function () {
                map.getBounds();
            });

            map.setView([51.505, -0.09], 13);
        });
    });

    describe('#setMaxBounds', function () {
        it("aligns pixel-wise map view center with maxBounds center if it cannot move view bounds inside maxBounds (#1908)", function () {
            var container = map.getContainer();
            // large view, cannot fit within maxBounds
            container.style.width = container.style.height = "1000px";
            document.body.appendChild(container);
            // maxBounds
            var bounds = L.latLngBounds([51.5, -0.05], [51.55, 0.05]);
            map.setMaxBounds(bounds, {animate: false});
            // set view outside
            map.setView(L.latLng([53.0, 0.15]), 12, {animate: false});
            // get center of bounds in pixels
            var boundsCenter = map.project(bounds.getCenter()).round();
            expect(map.project(map.getCenter()).round()).to.eql(boundsCenter);
            document.body.removeChild(container);
        });
        it("moves map view within maxBounds by changing one coordinate", function () {
            var container = map.getContainer();
            // small view, can fit within maxBounds
            container.style.width = container.style.height = "200px";
            document.body.appendChild(container);
            // maxBounds
            var bounds = L.latLngBounds([51, -0.2], [52, 0.2]);
            map.setMaxBounds(bounds, {animate: false});
            // set view outside maxBounds on one direction only
            // leaves untouched the other coordinate (that is not already centered)
            var initCenter = [53.0, 0.1];
            map.setView(L.latLng(initCenter), 16, {animate: false});
            // one pixel coordinate hasn't changed, the other has
            var pixelCenter = map.project(map.getCenter()).round();
            var pixelInit = map.project(initCenter).round();
            expect(pixelCenter.x).to.eql(pixelInit.x);
            expect(pixelCenter.y).not.to.eql(pixelInit.y);
            // the view is inside the bounds
            expect(bounds.contains(map.getBounds())).to.be(true);
            document.body.removeChild(container);
        });
    });

    describe("#getMinZoom and #getMaxZoom", function () {
        describe('#getMinZoom', function () {
            it('returns 0 if not set by Map options or TileLayer options', function () {
                var map = L.map(document.createElement('div'));
                expect(map.getMinZoom()).to.be(0);
            });
        });

        it("minZoom and maxZoom options overrides any minZoom and maxZoom set on layers", function () {

            var map = L.map(document.createElement('div'), {minZoom: 2, maxZoom: 20});

            L.tileLayer("{z}{x}{y}", {minZoom: 4, maxZoom: 10}).addTo(map);
            L.tileLayer("{z}{x}{y}", {minZoom: 6, maxZoom: 17}).addTo(map);
            L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 22}).addTo(map);

            expect(map.getMinZoom()).to.be(2);
            expect(map.getMaxZoom()).to.be(20);
        });
    });

    describe("#getMinZoom and #getMaxZoom", function () {
        describe('#getMinZoom', function () {
            it('returns 0 if not set by Map options or TileLayer options', function () {
                var map = L.map(document.createElement('div'));
                expect(map.getMinZoom()).to.be(0);
            });
        });

        it("minZoom and maxZoom options overrides any minZoom and maxZoom set on layers", function () {

            var map = L.map(document.createElement('div'), {minZoom: 2, maxZoom: 20});

            L.tileLayer("{z}{x}{y}", {minZoom: 4, maxZoom: 10}).addTo(map);
            L.tileLayer("{z}{x}{y}", {minZoom: 6, maxZoom: 17}).addTo(map);
            L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 22}).addTo(map);

            expect(map.getMinZoom()).to.be(2);
            expect(map.getMaxZoom()).to.be(20);
        });
    });

    describe("#hasLayer", function () {
        it("returns false when passed undefined, null, or false", function () {
            var map = L.map(document.createElement('div'));
            expect(map.hasLayer(undefined)).to.equal(false);
            expect(map.hasLayer(null)).to.equal(false);
            expect(map.hasLayer(false)).to.equal(false);
        });
    });

    function layerSpy() {
        var layer = new L.Layer();
        layer.onAdd = sinon.spy();
        layer.onRemove = sinon.spy();
        return layer;
    }

    describe("#addLayer", function () {

        it("calls layer.onAdd immediately if the map is ready", function () {
            var layer = layerSpy();
            map.setView([0, 0], 0);
            map.addLayer(layer);
            expect(layer.onAdd.called).to.be.ok();
        });

        it("calls layer.onAdd when the map becomes ready", function () {
            var layer = layerSpy();
            map.addLayer(layer);
            expect(layer.onAdd.called).not.to.be.ok();
            map.setView([0, 0], 0);
            expect(layer.onAdd.called).to.be.ok();
        });

        it("does not call layer.onAdd if the layer is removed before the map becomes ready", function () {
            var layer = layerSpy();
            map.addLayer(layer);
            map.removeLayer(layer);
            map.setView([0, 0], 0);
            expect(layer.onAdd.called).not.to.be.ok();
        });

        it("fires a layeradd event immediately if the map is ready", function () {
            var layer = layerSpy(),
                spy = sinon.spy();
            map.on('layeradd', spy);
            map.setView([0, 0], 0);
            map.addLayer(layer);
            expect(spy.called).to.be.ok();
        });

        it("fires a layeradd event when the map becomes ready", function () {
            var layer = layerSpy(),
                spy = sinon.spy();
            map.on('layeradd', spy);
            map.addLayer(layer);
            expect(spy.called).not.to.be.ok();
            map.setView([0, 0], 0);
            expect(spy.called).to.be.ok();
        });

        it("does not fire a layeradd event if the layer is removed before the map becomes ready", function () {
            var layer = layerSpy(),
                spy = sinon.spy();
            map.on('layeradd', spy);
            map.addLayer(layer);
            map.removeLayer(layer);
            map.setView([0, 0], 0);
            expect(spy.called).not.to.be.ok();
        });

        it("adds the layer before firing layeradd", function (done) {
            var layer = layerSpy();
            map.on('layeradd', function () {
                expect(map.hasLayer(layer)).to.be.ok();
                done();
            });
            map.setView([0, 0], 0);
            map.addLayer(layer);
        });

        // Skip because we have base layer with greater zooms.
        describe.skip("When the first layer is added to a map", function () {
            it("fires a zoomlevelschange event", function () {
                var spy = sinon.spy();
                map.on("zoomlevelschange", spy);
                expect(spy.called).not.to.be.ok();
                L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map);
                expect(spy.called).to.be.ok();
            });
        });

        // Skip because we have base layer with greater zooms.
        describe.skip("when a new layer with greater zoomlevel coverage than the current layer is added to a map", function () {
            it("fires a zoomlevelschange event", function () {
                var spy = sinon.spy();
                L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map);
                map.on("zoomlevelschange", spy);
                expect(spy.called).not.to.be.ok();
                L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 15}).addTo(map);
                expect(spy.called).to.be.ok();
            });
        });

        describe("when a new layer with the same or lower zoomlevel coverage as the current layer is added to a map", function () {
            it("fires no zoomlevelschange event", function () {
                var spy = sinon.spy();
                L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map);
                map.on("zoomlevelschange", spy);
                expect(spy.called).not.to.be.ok();
                L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map);
                expect(spy.called).not.to.be.ok();
                L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 5}).addTo(map);
                expect(spy.called).not.to.be.ok();
            });
        });
    });

    describe("#removeLayer", function () {
        it("calls layer.onRemove if the map is ready", function () {
            var layer = layerSpy();
            map.setView([0, 0], 0);
            map.addLayer(layer);
            map.removeLayer(layer);
            expect(layer.onRemove.called).to.be.ok();
        });

        it("does not call layer.onRemove if the layer was not added", function () {
            var layer = layerSpy();
            map.setView([0, 0], 0);
            map.removeLayer(layer);
            expect(layer.onRemove.called).not.to.be.ok();
        });

        it("does not call layer.onRemove if the map is not ready", function () {
            var layer = layerSpy();
            map.addLayer(layer);
            map.removeLayer(layer);
            expect(layer.onRemove.called).not.to.be.ok();
        });

        it("fires a layerremove event if the map is ready", function () {
            var layer = layerSpy(),
                spy = sinon.spy();
            map.on('layerremove', spy);
            map.setView([0, 0], 0);
            map.addLayer(layer);
            map.removeLayer(layer);
            expect(spy.called).to.be.ok();
        });

        it("does not fire a layerremove if the layer was not added", function () {
            var layer = layerSpy(),
                spy = sinon.spy();
            map.on('layerremove', spy);
            map.setView([0, 0], 0);
            map.removeLayer(layer);
            expect(spy.called).not.to.be.ok();
        });

        it("does not fire a layerremove if the map is not ready", function () {
            var layer = layerSpy(),
                spy = sinon.spy();
            map.on('layerremove', spy);
            map.addLayer(layer);
            map.removeLayer(layer);
            expect(spy.called).not.to.be.ok();
        });

        it("removes the layer before firing layerremove", function (done) {
            var layer = layerSpy();
            map.on('layerremove', function () {
                expect(map.hasLayer(layer)).not.to.be.ok();
                done();
            });
            map.setView([0, 0], 0);
            map.addLayer(layer);
            map.removeLayer(layer);
        });

        it("supports adding and removing a tile layer without initializing the map", function () {
            var layer = L.tileLayer("{z}{x}{y}");
            map.addLayer(layer);
            map.removeLayer(layer);
        });

        it("supports adding and removing a tile layer without initializing the map", function () {
            map.setView([0, 0], 18);
            var layer = L.gridLayer();
            map.addLayer(layer);
            map.removeLayer(layer);
        });

        describe("when the last tile layer on a map is removed", function () {
            it("fires a zoomlevelschange event", function () {
                map.whenReady(function () {
                    var spy = sinon.spy();
                    var tl = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map);

                    map.on("zoomlevelschange", spy);
                    expect(spy.called).not.to.be.ok();
                    map.removeLayer(tl);
                    expect(spy.called).to.be.ok();
                });
            });
        });

        describe("when a tile layer is removed from a map and it had greater zoom level coverage than the remainding layer", function () {
            it("fires a zoomlevelschange event", function () {
                map.whenReady(function () {
                    var spy = sinon.spy(),
                        tl = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map),
                        t2 = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 15}).addTo(map);

                    map.on("zoomlevelschange", spy);
                    expect(spy.called).to.not.be.ok();
                    map.removeLayer(t2);
                    expect(spy.called).to.be.ok();
                });
            });
        });

        describe("when a tile layer is removed from a map it and it had lesser or the sa,e zoom level coverage as the remainding layer(s)", function () {
            it("fires no zoomlevelschange event", function () {
                map.whenReady(function () {
                    var tl = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map),
                        t2 = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 10}).addTo(map),
                        t3 = L.tileLayer("{z}{x}{y}", {minZoom: 0, maxZoom: 5}).addTo(map);

                    map.on("zoomlevelschange", spy);
                    expect(spy).not.toHaveBeenCalled();
                    map.removeLayer(t2);
                    expect(spy).not.toHaveBeenCalled();
                    map.removeLayer(t3);
                    expect(spy).not.toHaveBeenCalled();
                });
            });
        });
    });

    describe("#eachLayer", function () {
        it("returns self", function () {
            expect(map.eachLayer(function () {})).to.be(map);
        });

        it("calls the provided function for each layer", function () {
            var t1 = L.tileLayer("{z}{x}{y}").addTo(map),
                t2 = L.tileLayer("{z}{x}{y}").addTo(map),
                spy = sinon.spy();

            map.eachLayer(spy);

            expect(spy.callCount).to.eql(2);
            expect(spy.firstCall.args).to.eql([t1]);
            expect(spy.secondCall.args).to.eql([t2]);
        });

        it("calls the provided function with the provided context", function () {
            var t1 = L.tileLayer("{z}{x}{y}").addTo(map),
                spy = sinon.spy();

            map.eachLayer(spy, map);

            expect(spy.thisValues[0]).to.eql(map);
        });
    });

    describe("#invalidateSize", function () {
        var container,
            origWidth = 100,
            clock;

        beforeEach(function () {
            container = map.getContainer();
            container.style.width = origWidth + "px";
            document.body.appendChild(container);
            map.setView([0, 0], 0);
            map.invalidateSize({pan: false});
            clock = sinon.useFakeTimers();
        });

        afterEach(function () {
            document.body.removeChild(container);
            clock.restore();
        });

        it("pans by the right amount when growing in 1px increments", function () {
            container.style.width = (origWidth + 1) + "px";
            map.invalidateSize();
            expect(map._getMapPanePos().x).to.be(1);

            container.style.width = (origWidth + 2) + "px";
            map.invalidateSize();
            expect(map._getMapPanePos().x).to.be(1);

            container.style.width = (origWidth + 3) + "px";
            map.invalidateSize();
            expect(map._getMapPanePos().x).to.be(2);
        });

        it("pans by the right amount when shrinking in 1px increments", function () {
            container.style.width = (origWidth - 1) + "px";
            map.invalidateSize();
            expect(map._getMapPanePos().x).to.be(0);

            container.style.width = (origWidth - 2) + "px";
            map.invalidateSize();
            expect(map._getMapPanePos().x).to.be(-1);

            container.style.width = (origWidth - 3) + "px";
            map.invalidateSize();
            expect(map._getMapPanePos().x).to.be(-1);
        });

        it("pans back to the original position after growing by an odd size and back", function () {
            container.style.width = (origWidth + 5) + "px";
            map.invalidateSize();

            container.style.width = origWidth + "px";
            map.invalidateSize();

            expect(map._getMapPanePos().x).to.be(0);
        });

        it("emits no move event if the size has not changed", function () {
            var spy = sinon.spy();
            map.on("move", spy);

            map.invalidateSize();

            expect(spy.called).not.to.be.ok();
        });

        it("emits a move event if the size has changed", function () {
            var spy = sinon.spy();
            map.on("move", spy);

            container.style.width = (origWidth + 5) + "px";
            map.invalidateSize();

            expect(spy.called).to.be.ok();
        });

        it("emits a moveend event if the size has changed", function () {
            var spy = sinon.spy();
            map.on("moveend", spy);

            container.style.width = (origWidth + 5) + "px";
            map.invalidateSize();

            expect(spy.called).to.be.ok();
        });

        it("debounces the moveend event if the debounceMoveend option is given", function () {
            var spy = sinon.spy();
            map.on("moveend", spy);

            container.style.width = (origWidth + 5) + "px";
            map.invalidateSize({debounceMoveend: true});

            expect(spy.called).not.to.be.ok();

            clock.tick(200);

            expect(spy.called).to.be.ok();
        });
    });

    describe('#flyTo', function () {

        it('move to requested center and zoom, and call zoomend once', function (done) {
            var spy = sinon.spy(),
                newCenter = new L.LatLng(10, 11),
                newZoom = 12;
            var callback = function () {
                expect(map.getCenter()).to.eql(newCenter);
                expect(map.getZoom()).to.eql(newZoom);
                spy();
                expect(spy.calledOnce).to.be.ok();
                done();
            };
            map.setView([0, 0], 0);
            map.once('zoomend', callback).flyTo(newCenter, newZoom);
        });

    });

    describe('#zoomIn and #zoomOut', function () {
        var center = L.latLng(22, 33);
        beforeEach(function () {
            map.setView(center, 10);
        });

        it('zoomIn zooms by 1 zoom level by default', function (done) {
            map.once('zoomend', function () {
                expect(map.getZoom()).to.eql(11);
                expect(map.getCenter()).to.eql(center);
                done();
            });
            map.zoomIn(null, {animate: false});
        });

        it('zoomOut zooms by 1 zoom level by default', function (done) {
            map.once('zoomend', function () {
                expect(map.getZoom()).to.eql(9);
                expect(map.getCenter()).to.eql(center);
                done();
            });
            map.zoomOut(null, {animate: false});
        });

        it('zoomIn ignores the zoomDelta option on non-any3d browsers', function (done) {
            L.Browser.any3d = false;
            map.options.zoomSnap = 0.25;
            map.options.zoomDelta = 0.25;
            map.once('zoomend', function () {
                expect(map.getZoom()).to.eql(11);
                expect(map.getCenter()).to.eql(center);
                done();
            });
            map.zoomIn(null, {animate: false});
        });

        it('zoomIn respects the zoomDelta option on any3d browsers', function (done) {
            L.Browser.any3d = true;
            map.options.zoomSnap = 0.25;
            map.options.zoomDelta = 0.25;
            map.setView(center, 10);
            map.once('zoomend', function () {
                expect(map.getZoom()).to.eql(10.25);
                expect(map.getCenter()).to.eql(center);
                done();
            });
            map.zoomIn(null, {animate: false});
        });

        it('zoomOut respects the zoomDelta option on any3d browsers', function (done) {
            L.Browser.any3d = true;
            map.options.zoomSnap = 0.25;
            map.options.zoomDelta = 0.25;
            map.setView(center, 10);
            map.once('zoomend', function () {
                expect(map.getZoom()).to.eql(9.75);
                expect(map.getCenter()).to.eql(center);
                done();
            });
            map.zoomOut(null, {animate: false});
        });

        it('zoomIn snaps to zoomSnap on any3d browsers', function (done) {
            map.options.zoomSnap = 0.25;
            map.setView(center, 10);
            map.once('zoomend', function () {
                expect(map.getZoom()).to.eql(10.25);
                expect(map.getCenter()).to.eql(center);
                done();
            });
            L.Browser.any3d = true;
            map.zoomIn(0.22, {animate: false});
        });

        it('zoomOut snaps to zoomSnap on any3d browsers', function (done) {
            map.options.zoomSnap = 0.25;
            map.setView(center, 10);
            map.once('zoomend', function () {
                expect(map.getZoom()).to.eql(9.75);
                expect(map.getCenter()).to.eql(center);
                done();
            });
            L.Browser.any3d = true;
            map.zoomOut(0.22, {animate: false});
        });
    });

    describe('#fitBounds', function () {
        var center = L.latLng(50.5, 30.51),
            bounds = L.latLngBounds(L.latLng(1, 102), L.latLng(11, 122)),
            boundsCenter = bounds.getCenter();

        beforeEach(function () {
            // fitBounds needs a map container with non-null area
            var container = map.getContainer();
            container.style.width = container.style.height = "100px";
            document.body.appendChild(container);
            map.setView(center, 15);
        });

        afterEach(function () {
            document.body.removeChild(map.getContainer());
        });

        it('Snaps zoom level to integer by default', function (done) {
            map.once('zoomend', function () {
                expect(map.getZoom()).to.eql(2);
                expect(map.getCenter().equals(boundsCenter, 0.05)).to.eql(true);
                done();
            });
            map.fitBounds(bounds, {animate: false});
        });

        it('Snaps zoom to zoomSnap on any3d browsers', function (done) {
            map.options.zoomSnap = 0.25;
            L.Browser.any3d = true;
            map.once('zoomend', function () {
                expect(map.getZoom()).to.eql(2.75);
                expect(map.getCenter().equals(boundsCenter, 0.05)).to.eql(true);
                done();
            });
            map.fitBounds(bounds, {animate: false});
        });

        it('Ignores zoomSnap on non-any3d browsers', function (done) {
            map.options.zoomSnap = 0.25;
            L.Browser.any3d = false;
            map.once('zoomend', function () {
                expect(map.getZoom()).to.eql(2);
                expect(map.getCenter().equals(boundsCenter, 0.05)).to.eql(true);
                done();
            });
            map.fitBounds(bounds, {animate: false});
        });

        it('can be called with an array', function (done) {
            map.once('zoomend', function () {
                expect(map.getZoom()).to.eql(2);
                expect(map.getCenter().equals(boundsCenter, 0.05)).to.eql(true);
                done();
            });
            var bounds = [[1, 102], [11, 122]];
            map.fitBounds(bounds, {animate: false});
        });

        it('throws an error with invalid bounds', function () {
            expect(function () {
                map.fitBounds(NaN);
            }).to.throwError();
        });

        it('Fits to same scale and zoom', function (done) {
            var bounds = map.getBounds(),
                zoom = map.getZoom();
            map.once('moveend zoomend', function () {
                var newBounds = map.getBounds();
                expect(newBounds.getSouthWest()).to.nearLatLng(bounds.getSouthWest());
                expect(newBounds.getNorthEast()).to.nearLatLng(bounds.getNorthEast());
                expect(map.getZoom()).to.eql(zoom);
                done();
            });
            map.fitBounds(bounds, {animate: false});
        });

        it('Fits to small bounds from small zoom', function (done) {
            map.once('zoomend', function () {
                map.once('zoomend', function () {
                    expect(map.getZoom()).to.eql(11);
                    expect(map.getCenter().equals(boundsCenter, 0.05)).to.eql(true);
                    done();
                });
                map.fitBounds(bounds);
            });

            bounds = L.latLngBounds([57.73, 11.93], [57.75, 11.95]);
            boundsCenter = bounds.getCenter();
            map.setZoom(0);
        });

        it('Fits to large bounds from large zoom', function (done) {
            map.once('zoomend', function () {
                map.once('zoomend', function () {
                    expect(map.getZoom()).to.eql(0);
                    expect(map.getCenter().equals(boundsCenter, 0.05)).to.eql(true);
                    done();
                });
                map.fitBounds(bounds);
            });

            bounds = L.latLngBounds([90, -180], [-90, 180]);
            boundsCenter = bounds.getCenter();
            map.setZoom(22);
        });
    });

    describe('#fitBounds after layers set', function () {
        var center = L.latLng(22, 33),
            bounds = L.latLngBounds(L.latLng(1, 102), L.latLng(11, 122)),
            boundsCenter = bounds.getCenter();

        beforeEach(function () {
            // fitBounds needs a map container with non-null area
            var container = map.getContainer();
            container.style.width = container.style.height = "100px";
            document.body.appendChild(container);
        });

        afterEach(function () {
            document.body.removeChild(map.getContainer());
        });

        it('Snaps to a number after adding tile layer', function (done) {
            L.Browser.any3d = true;
            map.addLayer(L.tileLayer('file:///dev/null'));
            expect(map.getZoom()).to.be(undefined);
            map.fitBounds(bounds);
            expect(map.getZoom()).to.be(2);
            done();
        });

        it('Snaps to a number after adding marker', function (done) {
            L.Browser.any3d = true;
            map.addLayer(L.marker(center));
            expect(map.getZoom()).to.be(undefined);
            map.fitBounds(bounds);
            expect(map.getZoom()).to.be(2);
            done();
        });

    });

    describe('#DOM events', function () {

        var c, map;

        beforeEach(function () {
            c = document.createElement('div');
            c.style.width = '400px';
            c.style.height = '400px';
            map = new L.Map(c);
            map.setView(new L.LatLng(0, 0), 0);
            document.body.appendChild(c);
        });

        afterEach(function () {
            document.body.removeChild(c);
        });

        it("DOM events propagate from polygon to map", function () {
            var spy = sinon.spy();
            map.on("mousemove", spy);
            var layer = new L.Polygon([[1, 2], [3, 4], [5, 6]]).addTo(map);
            happen.mousemove(layer._path);
            expect(spy.calledOnce).to.be.ok();
        });

        it("DOM events propagate from marker to map", function () {
            var spy = sinon.spy();
            map.on("mousemove", spy);
            var layer = new L.Marker([1, 2]).addTo(map);
            happen.mousemove(layer._icon);
            expect(spy.calledOnce).to.be.ok();
        });

        it("DOM events fired on marker can be cancelled before being caught by the map", function () {
            var mapSpy = sinon.spy();
            var layerSpy = sinon.spy();
            map.on("mousemove", mapSpy);
            var layer = new L.Marker([1, 2]).addTo(map);
            layer.on("mousemove", L.DomEvent.stopPropagation).on("mousemove", layerSpy);
            happen.mousemove(layer._icon);
            expect(layerSpy.calledOnce).to.be.ok();
            expect(mapSpy.called).not.to.be.ok();
        });

        it("DOM events fired on polygon can be cancelled before being caught by the map", function () {
            var mapSpy = sinon.spy();
            var layerSpy = sinon.spy();
            map.on("mousemove", mapSpy);
            var layer = new L.Polygon([[1, 2], [3, 4], [5, 6]]).addTo(map);
            layer.on("mousemove", L.DomEvent.stopPropagation).on("mousemove", layerSpy);
            happen.mousemove(layer._path);
            expect(layerSpy.calledOnce).to.be.ok();
            expect(mapSpy.called).not.to.be.ok();
        });

        it("mouseout is forwarded if fired on the original target", function () {
            var mapSpy = sinon.spy(),
                layerSpy = sinon.spy(),
                otherSpy = sinon.spy();
            var layer = new L.Polygon([[1, 2], [3, 4], [5, 6]]).addTo(map);
            var other = new L.Polygon([[10, 20], [30, 40], [50, 60]]).addTo(map);
            map.on("mouseout", mapSpy);
            layer.on("mouseout", layerSpy);
            other.on("mouseout", otherSpy);
            happen.mouseout(layer._path, {relatedTarget: map._container});
            expect(mapSpy.called).not.to.be.ok();
            expect(otherSpy.called).not.to.be.ok();
            expect(layerSpy.calledOnce).to.be.ok();
        });

        it("mouseout is forwarded when using a DivIcon", function () {
            var icon = L.divIcon({
                html: "<p>this is text in a child element</p>",
                iconSize: [100, 100]
            });
            var mapSpy = sinon.spy(),
                layerSpy = sinon.spy(),
                layer = L.marker([1, 2], {icon: icon}).addTo(map);
            map.on("mouseout", mapSpy);
            layer.on("mouseout", layerSpy);
            happen.mouseout(layer._icon, {relatedTarget: map._container});
            expect(mapSpy.called).not.to.be.ok();
            expect(layerSpy.calledOnce).to.be.ok();
        });

        it("mouseout is not forwarded if relatedTarget is a target's child", function () {
            var icon = L.divIcon({
                html: "<p>this is text in a child element</p>",
                iconSize: [100, 100]
            });
            var mapSpy = sinon.spy(),
                layerSpy = sinon.spy(),
                layer = L.marker([1, 2], {icon: icon}).addTo(map),
                child = layer._icon.querySelector('p');
            map.on("mouseout", mapSpy);
            layer.on("mouseout", layerSpy);
            happen.mouseout(layer._icon, {relatedTarget: child});
            expect(mapSpy.called).not.to.be.ok();
            expect(layerSpy.calledOnce).not.to.be.ok();
        });

        it("mouseout is not forwarded if fired on target's child", function () {
            var icon = L.divIcon({
                html: "<p>this is text in a child element</p>",
                iconSize: [100, 100]
            });
            var mapSpy = sinon.spy(),
                layerSpy = sinon.spy(),
                layer = L.marker([1, 2], {icon: icon}).addTo(map),
                child = layer._icon.querySelector('p');
            map.on("mouseout", mapSpy);
            layer.on("mouseout", layerSpy);
            happen.mouseout(child, {relatedTarget: layer._icon});
            expect(mapSpy.called).not.to.be.ok();
            expect(layerSpy.calledOnce).not.to.be.ok();
        });

        it("mouseout is not forwarded to layers if fired on the map", function () {
            var mapSpy = sinon.spy(),
                layerSpy = sinon.spy(),
                otherSpy = sinon.spy();
            var layer = new L.Polygon([[1, 2], [3, 4], [5, 6]]).addTo(map);
            var other = new L.Polygon([[10, 20], [30, 40], [50, 60]]).addTo(map);
            map.on("mouseout", mapSpy);
            layer.on("mouseout", layerSpy);
            other.on("mouseout", otherSpy);
            happen.mouseout(map._container);
            expect(otherSpy.called).not.to.be.ok();
            expect(layerSpy.called).not.to.be.ok();
            expect(mapSpy.calledOnce).to.be.ok();
        });

        it("preclick is fired before click on marker and map", function () {
            var called = 0;
            var layer = new L.Marker([1, 2]).addTo(map);
            layer.on("preclick", function (e) {
                expect(called++).to.eql(0);
                expect(e.latlng).to.ok();
            });
            layer.on("click", function (e) {
                expect(called++).to.eql(2);
                expect(e.latlng).to.ok();
            });
            map.on("preclick", function (e) {
                expect(called++).to.eql(1);
                expect(e.latlng).to.ok();
            });
            map.on("click", function (e) {
                expect(called++).to.eql(3);
                expect(e.latlng).to.ok();
            });
            happen.click(layer._icon);
        });

    });

    describe('#getScaleZoom && #getZoomScale', function () {
        it("convert zoom to scale and viceversa and return the same values", function () {
            var toZoom = 6.25;
            var fromZoom = 8.5;
            var scale = map.getScaleZoom(toZoom, fromZoom);
            expect(Math.round(map.getZoomScale(scale, fromZoom) * 100) / 100).to.eql(toZoom);
        });
    });

    describe('#getZoom', function () {
        it("returns undefined if map not initialized", function () {
            expect(map.getZoom()).to.be(undefined);
        });

        it("returns undefined if map not initialized but layers added", function () {
            map.addLayer(L.tileLayer('file:///dev/null'));
            expect(map.getZoom()).to.be(undefined);
        });
    });
});


================================================
FILE: src/DGCustomization/test/PathSpec.js
================================================
describe('Path', function () {
    describe('#bringToBack', function () {
        it('is a no-op for layers not on a map', function () {
            var path = new L.Path();
            expect(path.bringToBack()).to.equal(path);
        });
    });

    describe('#bringToFront', function () {
        it('is a no-op for layers not on a map', function () {
            var path = new L.Path();
            expect(path.bringToFront()).to.equal(path);
        });
    });

    describe('#events', function () {

        var c, map;

        beforeEach(function () {
            c = document.createElement('div');
            c.style.width = '400px';
            c.style.height = '400px';
            map = new L.Map(c);
            map.setView(new L.LatLng(0, 0), 0);
            document.body.appendChild(c);
        });

        afterEach(function () {
            document.body.removeChild(c);
        });

        it('fires click event', function () {
            var spy = sinon.spy();
            var layer = new L.Polygon([[1, 2], [3, 4], [5, 6]]).addTo(map);
            layer.on('click', spy);
            happen.click(layer._path);
            expect(spy.called).to.be.ok();
        });

        it('propagates click event by default', function () {
            var spy = sinon.spy();
            var spy2 = sinon.spy();
            var mapSpy = sinon.spy();
            var layer = new L.Polygon([[1, 2], [3, 4], [5, 6]]).addTo(map);
            layer.on('click', spy);
            layer.on('click', spy2);
            map.on('click', mapSpy);
            happen.click(layer._path);
            expect(spy.called).to.be.ok();
            expect(spy2.called).to.be.ok();
            expect(mapSpy.called).to.be.ok();
        });

        it('can add a layer while being inside a moveend handler', function (done) {
            var zoneLayer = L.layerGroup();
            var polygon;
            map.addLayer(zoneLayer);

            map.on('moveend', function () {
                zoneLayer.clearLayers();
                polygon = new L.Polygon([[1, 2], [3, 4], [5, 6]]);
                zoneLayer.addLayer(polygon);
            });

            map.invalidateSize();
            map.setView([1, 2], 12, {animate: false});

            map.panBy([-260, 0]);
            setTimeout(function () {
                expect(polygon._parts.length).to.be(0);
                map.panBy([260, 0]);
                setTimeout(function () {
                    expect(polygon._parts.length).to.be(1);
                    done();
                }, 300);
            }, 300);
        });
    });
});


================================================
FILE: src/DGCustomization/test/PopupSpec.js
================================================
describe('Popup', function () {

    var c, map;

    beforeEach(function () {
        c = document.createElement('div');
        c.style.width = '400px';
        c.style.height = '400px';
        document.body.appendChild(c);
        map = new L.Map(c);
        map.setView(new L.LatLng(55.8, 37.6), 6);
    });

    afterEach(function () {
        document.body.removeChild(c);
    });

    it("closes on map click when map has closePopupOnClick option", function () {
        map.options.closePopupOnClick = true;

        var popup = new L.Popup()
            .setLatLng(new L.LatLng(55.8, 37.6))
            .openOn(map);

        happen.click(c);

        expect(map.hasLayer(popup)).to.be(false);
    });

    it("closes on map click when popup has closeOnClick option", function () {
        map.options.closePopupOnClick = false;

        var popup = new L.Popup({closeOnClick: true})
            .setLatLng(new L.LatLng(55.8, 37.6))
            .openOn(map);

        happen.click(c);

        expect(map.hasLayer(popup)).to.be(false);
    });

    it("does not close on map click when popup has closeOnClick: false option", function () {
        map.options.closePopupOnClick = true;

        var popup = new L.Popup({closeOnClick: false})
            .setLatLng(new L.LatLng(55.8, 37.6))
            .openOn(map);

        happen.click(c);

        expect(map.hasLayer(popup)).to.be(true);
    });

    it("toggles its visibility when marker is clicked", function () {
        var marker = new L.Marker(new L.LatLng(55.8, 37.6));
        map.addLayer(marker);

        marker.bindPopup('Popup1');
        expect(map.hasLayer(marker._popup)).to.be(false);

        // toggle open popup
        happen.click(marker._icon);
        expect(map.hasLayer(marker._popup)).to.be(true);

        // toggle close popup
        happen.click(marker._icon);
        expect(map.hasLayer(marker._popup)).to.be(false);
    });

    it.skip("it should use a popup with a function as content with a FeatureGroup", function () {
        var marker1 = new L.Marker(new L.LatLng(55.8, 37.6));
        var marker2 = new L.Marker(new L.LatLng(54.6, 38.2));
        var group = new L.FeatureGroup([marker1, marker2]).addTo(map);

        marker1.description = "I'm marker 1.";
        marker2.description = "I'm marker 2.";
        group.bindPopup(function (layer) {
            return layer.description;
        });

        map.options.closePopupOnClick = true;

        // toggle popup on marker1
        group.fire('click', {
            latlng: new L.LatLng(55.8, 37.6),
            layer: marker1
        });
        expect(map.hasLayer(group._popup)).to.be(true);
        expect(group._popup._contentNode.innerHTML).to.be("I'm marker 1.");

        // toggle popup on marker2
        group.fire('click', {
            latlng: new L.LatLng(54.6, 38.2),
            layer: marker2
        });
        expect(map.hasLayer(group._popup)).to.be(true);
        expect(group._popup._contentNode.innerHTML).to.be("I'm marker 2.");
    });

    it.skip("it should function for popup content after bindPopup is called", function () {
        var marker1 = new L.Marker(new L.LatLng(55.8, 37.6));
        var marker2 = new L.Marker(new L.LatLng(54.6, 38.2));
        var group = new L.FeatureGroup([marker1]).addTo(map);

        marker1.description = "I'm marker 1.";
        marker2.description = "I'm marker 2.";
        group.bindPopup(function (layer) {
            return layer.description;
        });

        group.addLayer(marker2);

        map.options.closePopupOnClick = true;

        // toggle popup on marker1
        group.fire('click', {
            latlng: new L.LatLng(55.8, 37.6),
            layer: marker1
        });
        expect(map.hasLayer(group._popup)).to.be(true);
        expect(group._popup._contentNode.innerHTML).to.be("I'm marker 1.");

        // toggle popup on marker2
        group.fire('click', {
            latlng: new L.LatLng(54.6, 38.2),
            layer: marker2
        });
        expect(map.hasLayer(group._popup)).to.be(true);
        expect(group._popup._contentNode.innerHTML).to.be("I'm marker 2.");
    });

    it.skip("should use a function for popup content when a source is passed to Popup", function () {
        var marker = new L.Marker(new L.LatLng(55.8, 37.6)).addTo(map);
        var popup = L.popup({}, marker);

        marker.description = "I am a marker.";

        marker.bindPopup(function (layer) {
            return layer.description;
        });

        marker.fire('click', {
            latlng: new L.LatLng(55.8, 37.6)
        });

        expect(map.hasLayer(marker._popup)).to.be(true);
        expect(marker._popup._contentNode.innerHTML).to.be("I am a marker.");
    });

    it("triggers popupopen on marker when popup opens", function () {
        var marker1 = new L.Marker(new L.LatLng(55.8, 37.6));
        var marker2 = new L.Marker(new L.LatLng(57.123076977278, 44.861962891635));

        map.addLayer(marker1);
        map.addLayer(marker2);

        marker1.bindPopup('Popup1');
        marker2.bindPopup('Popup2');

        var spy = sinon.spy();

        marker1.on('popupopen', spy);

        expect(spy.called).to.be(false);
        marker2.openPopup();
        expect(spy.called).to.be(false);
        marker1.openPopup();
        expect(spy.called).to.be(true);
    });

    it("triggers popupclose on marker when popup closes", function () {
        var marker1 = new L.Marker(new L.LatLng(55.8, 37.6));
        var marker2 = new L.Marker(new L.LatLng(57.123076977278, 44.861962891635));

        map.addLayer(marker1);
        map.addLayer(marker2);

        marker1.bindPopup('Popup1');
        marker2.bindPopup('Popup2');

        var spy = sinon.spy();

        marker1.on('popupclose', spy);

        expect(spy.called).to.be(false);
        marker2.openPopup();
        expect(spy.called).to.be(false);
        marker1.openPopup();
        expect(spy.called).to.be(false);
        marker2.openPopup();
        expect(spy.called).to.be(true);
        marker1.openPopup();
        marker1.closePopup();
        expect(spy.callCount).to.be(2);
    });

    it("should take into account icon popupAnchor option", function () {
        var autoPanBefore = L.Popup.prototype.options.autoPan;
        L.Popup.prototype.options.autoPan = false;
        var popupAnchorBefore = L.Icon.Default.prototype.options.popupAnchor;
        L.Icon.Default.prototype.options.popupAnchor = [0, 0];

        var latlng = new L.LatLng(55.8, 37.6),
            offset = new L.Point(20, 30),
            icon = new L.DivIcon({popupAnchor: offset}),
            marker1 = new L.Marker(latlng),
            marker2 = new L.Marker(latlng, {icon: icon});

        marker1.bindPopup('Popup').addTo(map);
        marker1.openPopup();
        var defaultLeft = parseInt(marker1._popup._container.style.left, 10);
        var defaultBottom = parseInt(marker1._popup._container.style.bottom, 10);
        marker2.bindPopup('Popup').addTo(map);
        marker2.openPopup();
        var offsetLeft = parseInt(marker2._popup._container.style.left, 10);
        var offsetBottom = parseInt(marker2._popup._container.style.bottom, 10);
        expect(offsetLeft - offset.x).to.eql(defaultLeft);
        expect(offsetBottom + offset.y).to.eql(defaultBottom);

        // Now retry passing a popup instance to bindPopup
        marker2.bindPopup(new L.Popup());
        marker2.openPopup();
        offsetLeft = parseInt(marker2._popup._container.style.left, 10);
        offsetBottom = parseInt(marker2._popup._container.style.bottom, 10);
        expect(offsetLeft - offset.x).to.eql(defaultLeft);
        expect(offsetBottom + offset.y).to.eql(defaultBottom);

        L.Popup.prototype.options.autoPan = autoPanBefore;
        L.Icon.Default.prototype.options.popupAnchor = popupAnchorBefore;
    });

    it("prevents an underlying map click for Layer", function () {
        var layer = new L.Polygon([[55.8, 37.6], [55.9, 37.7], [56.0, 37.8]]).addTo(map);
        layer.bindPopup("layer popup");

        var mapClicked = false;
        map.on('click', function (e) {
            mapClicked = true;
            new L.Popup()
                .setLatLng(e.latlng)
                .setContent("map popup")
                .openOn(map);
        });

        expect(map.hasLayer(layer._popup)).to.be(false);
        happen.click(layer._path);
        expect(mapClicked).to.be(false);
        expect(map.hasLayer(layer._popup)).to.be(true);
    });

});

describe("L.Map#openPopup", function () {
    var c, map;

    beforeEach(function () {
        c = document.createElement('div');
        c.style.width = '400px';
        c.style.height = '400px';
        map = new L.Map(c);
        map.setView(new L.LatLng(55.8, 37.6), 6);
    });

    it("adds the popup layer to the map", function () {
        var popup = new L.Popup()
            .setLatLng(new L.LatLng(55.8, 37.6));
        map.openPopup(popup);
        expect(map.hasLayer(popup)).to.be(true);
    });

    it("sets popup location", function () {
        var popup = new L.Popup();
        map.openPopup(popup, L.latLng(55.8, 37.6));
        expect(popup.getLatLng()).to.eql(L.latLng(55.8, 37.6));
    });

    it("creates a popup from content", function () {
        map.openPopup("<h2>Hello World</h2>", L.latLng(55.8, 37.6));
        expect(map._popup).to.be.an(L.Popup);
        expect(map._popup.getContent()).to.eql("<h2>Hello World</h2>");
    });

    it("closes existing popup", function () {
        var p1 = new L.Popup().setLatLng(new L.LatLng(55.8, 37.6));
        var p2 = new L.Popup().setLatLng(new L.LatLng(55.8, 37.6));
        map.openPopup(p1);
        map.openPopup(p2);
        expect(map.hasLayer(p1)).to.be(false);
    });

    it("does not close existing popup with autoClose: false option", function () {
        var p1 = new L.Popup({autoClose: false}).setLatLng(new L.LatLng(55.8, 37.6));
        var p2 = new L.Popup().setLatLng(new L.LatLng(55.8, 37.6));
        map.openPopup(p1);
        map.openPopup(p2);
        expect(map.hasLayer(p1)).to.be(true);
        expect(map.hasLayer(p2)).to.be(true);
    });

    it('should not be closed when dragging map', function (done) {
        document.body.appendChild(c);
        c.style.position = 'absolute';
        c.style.left = 0;
        c.style.top = 0;
        c.style.zIndex = 10000;
        var coords = map._container.getBoundingClientRect();
        var spy = sinon.spy();
        var p = new L.Popup().setLatLng(new L.LatLng(55.8, 37.6));
        map.openPopup(p);
        expect(map.hasLayer(p)).to.be(true);
        map.on('drag', spy);
        var hand = new Hand({
            timing: 'fastframe',
            onStop: function () {
                expect(spy.called).to.be(true);
                expect(map.hasLayer(p)).to.be(true);
                document.body.removeChild(c);
                done();
            }
        });
        var toucher = hand.growFinger('touch');
        toucher.moveTo(coords.left + 100, coords.top + 100, 0).down().moveBy(10, 10, 20).up();
    });
});


================================================
FILE: src/DGCustomization/test/UtilSpec.js
================================================
describe('Util', function () {

    describe('#extend', function () {
        var a;

        beforeEach(function () {
            a = {
                foo: 5,
                bar: 'asd'
            };
        });

        it('extends the first argument with the properties of the second', function () {
            L.Util.extend(a, {
                bar: 7,
                baz: 3
            });

            expect(a).to.eql({
                foo: 5,
                bar: 7,
                baz: 3
            });
        });

        it('accepts more than 2 arguments', function () {
            L.Util.extend(a, {bar: 7}, {baz: 3});

            expect(a).to.eql({
                foo: 5,
                bar: 7,
                baz: 3
            });
        });
    });

    describe('#bind', function () {
        it('returns the given function with the given context', function () {
            var fn = function () {
                return this;
            };

            var fn2 = L.Util.bind(fn, {foo: 'bar'});

            expect(fn2()).to.eql({foo: 'bar'});
        });

        it('passes additional arguments to the bound function', function () {
            var fn = sinon.spy(),
                foo = {},
                a = {},
                b = {},
                c = {};

            var fn2 = L.Util.bind(fn, foo, a, b);

            fn2(c);

            expect(fn.calledWith(a, b, c)).to.be.ok();
        });
    });

    describe('#stamp', function () {
        it('sets a unique id on the given object and returns it', function () {
            var a = {},
                id = L.Util.stamp(a);

            expect(typeof id).to.eql('number');
            expect(L.Util.stamp(a)).to.eql(id);

            var b = {},
                id2 = L.Util.stamp(b);

            expect(id2).not.to.eql(id);
        });
    });

    describe('#falseFn', function () {
        it('returns false', function () {
            expect(L.Util.falseFn()).to.be(false);
        });
    });

    describe('#formatNum', function () {
        it('formats numbers with a given precision', function () {
            expect(L.Util.formatNum(13.12325555, 3)).to.eql(13.123);
            expect(L.Util.formatNum(13.12325555)).to.eql(13.12326);
        });
    });


    describe('#getParamString', function () {
        it('creates a valid query string for appending depending on url input', function () {
            var a = {
                url: 'http://example.com/get',
                obj: {bar: 7, baz: 3},
                result: '?bar=7&baz=3'
            };

            expect(L.Util.getParamString(a.obj, a.url)).to.eql(a.result);

            var b = {
                url: 'http://example.com/get?justone=qs',
                obj: {bar: 7, baz: 3},
                result: '&bar=7&baz=3'
            };

            expect(L.Util.getParamString(b.obj, b.url)).to.eql(b.result);

            var c = {
                url: undefined,
                obj: {bar: 7, baz: 3},
                result: '?bar=7&baz=3'
            };

            expect(L.Util.getParamString(c.obj, c.url)).to.eql(c.result);
        });
    });

    describe('#requestAnimFrame', function () {
        it('calles a function on next frame, unless canceled', function (done) {
            var spy = sinon.spy(),
                foo = {};

            L.Util.requestAnimFrame(spy);

            L.Util.requestAnimFrame(function () {
                expect(this).to.eql(foo);
                done();
            }, foo);

            L.Util.cancelAnimFrame(spy);
        });
    });

    describe('#throttle', function () {
        it('limits execution to not more often than specified time interval', function (done) {
            var spy = sinon.spy();

            var fn = L.Util.throttle(spy, 20);

            fn();
            fn();
            fn();

            expect(spy.callCount).to.eql(1);

            setTimeout(function () {
                expect(spy.callCount).to.eql(2);
                done();
            }, 30);
        });
    });

    describe('#splitWords', function () {
        it('splits words into an array', function () {
            expect(L.Util.splitWords('foo bar baz')).to.eql(['foo', 'bar', 'baz']);
        });
    });

    describe('#setOptions', function () {
        it('sets specified options on object', function () {
            var o = {};
            L.Util.setOptions(o, {foo: 'bar'});
            expect(o.options.foo).to.eql('bar');
        });

        it('returns options', function () {
            var o = {};
            var r = L.Util.setOptions(o, {foo: 'bar'});
            expect(r).to.equal(o.options);
        });

        it('accepts undefined', function () {
            var o = {};
            L.Util.setOptions(o, undefined);
            expect(o.options).to.eql({});
        });

        it('creates a distinct options object', function () {
            var opts = {},
                o = L.Util.create({options: opts});
            L.Util.setOptions(o, {});
            expect(o.options).not.to.equal(opts);
        });

        it("doesn't create a distinct options object if object already has own options", function () {
            var opts = {},
                o = {options: opts};
            L.Util.setOptions(o, {});
            expect(o.options).to.equal(opts);
        });

        it('inherits options prototypally', function () {
            var opts = {},
                o = L.Util.create({options: opts});
            L.Util.setOptions(o, {});
            opts.foo = 'bar';
            expect(o.options.foo).to.eql('bar');
        });
    });

    describe('#template', function () {
        it('evaluates templates with a given data object', function () {
            var tpl = 'Hello {foo} and {bar}!';

            var str = L.Util.template(tpl, {
                foo: 'Vlad',
                bar: 'Dave'
            });

            expect(str).to.eql('Hello Vlad and Dave!');
        });
        it('does not modify text without a token variable', function () {
            expect(L.Util.template('foo', {})).to.eql('foo');
        });

        it('supports templates with double quotes', function () {
            expect(L.Util.template('He said: "{foo}"!', {
                foo: 'Hello'
            })).to.eql('He said: "Hello"!');
        });

        it('throws when a template token is not given', function () {
            expect(function () {
                L.Util.template(undefined, {foo: 'bar'});
            }).to.throwError();
        });

        it('allows underscores and dashes in placeholders', function () {
            expect(L.Util.template('{nice_stuff}', {'nice_stuff': 'foo'})).to.eql('foo');
            expect(L.Util.template('{-y}', {'-y': 1})).to.eql('1');
        });
    });

    describe('#isArray', function () {
        expect(L.Util.isArray([1, 2, 3])).to.be(true);
        /* eslint no-array-constructor: 0 */
        expect(L.Util.isArray(new Array(1, 2, 3))).to.be(true);
        expect(L.Util.isArray('blabla')).to.be(false);
        expect(L.Util.isArray({0: 1, 1: 2})).to.be(false);
    });
});


================================================
FILE: src/DGCustomization/test/ValidatorApiKeySpec.js
================================================
describe('DG.ApiKeyValidator', function() {
    afterEach(function() {
        validator = null;
    });

    describe('#validate', function() {
        var xhr;
        var requests = [];
        var testApiKey = window.__karma__.config.secretKey;
        var validator;
        beforeEach(function() {
            validator = new DG.ApiKeyValidator(testApiKey);
            xhr = sinon.useFakeXMLHttpRequest();
            requests = [];
            xhr.onCreate = function(req) { requests.push(req); };
        });

        afterEach(function() {
            xhr.restore();
            validator.destroy();
            validator = null;
        });


        it('should make a request to the correct endpoint', function() {
            validator.validate(function() {});
            expect(requests.length).to.be(1);
            expect(requests[0].url).to.be(validator.endpoint);
            expect(requests[0].method).to.be('GET');
        });

        it('should handle successful response', function(done) {
            var response = {
                meta: {code: 200},
                result: {
                    // eslint-disable-next-line camelcase
                    is_active: true,
                    service: {
                        // eslint-disable-next-line camelcase
                        is_active: true,
                        status: {
                            code: 'ok'
                        }
                    }
                }
            };

            validator.validate(function(result) {
                expect(result.result.service.is_active).to.eql(response.result.service.is_active);
                expect(validator.isLoading).to.be(false);
                done();
            });

            requests[0].respond(200, {'Content-Type': 'application/json'}, JSON.stringify(response));
        });
    });

    describe('#invalid', function() {
        var xhr;
        var requests = [];
        var invalidApiKey = window.__karma__.config.secretInvalidKey;
        var validator;
        beforeEach(function() {
            validator = new DG.ApiKeyValidator(invalidApiKey);
            xhr = sinon.useFakeXMLHttpRequest();
            requests = [];
            xhr.onCreate = function(req) { requests.push(req); };
        });

        afterEach(function() {
            xhr.restore();
            validator.destroy();
            validator = null;
        });

        it('should handle insecure response the key service is blocked', function(done) {
            var response = {
                meta: {code: 200},
                result: {
                    // eslint-disable-next-line camelcase
                    is_active: false,
                    service: {
                        // eslint-disable-next-line camelcase
                        is_active: false,
                        status: {
                            code: 'blocked'
                        }
                    }
                }
            };

            validator.validate(function(result) {
                expect(result.result.service.is_active).to.eql(response.result.service.is_active);
                expect(validator.isLoading).to.be(false);
                done();
            });

            requests[0].respond(200, {'Content-Type': 'application/json'}, JSON.stringify(response));
        });
    });

    describe('#empty', function() {
        var xhr;
        var requests = [];
        var validator;
        beforeEach(function() {
            validator = new DG.ApiKeyValidator('');
            xhr = sinon.useFakeXMLHttpRequest();
            requests = [];
            xhr.onCreate = function(req) { requests.push(req); };
        });

        afterEach(function() {
            xhr.restore();
            validator.destroy();
            validator = null;
        });

        it('should handle insecure response without key', function(done) {
            var response = {
                meta: {code: 400},
                result: {}
            };

            validator.validate(function(result) {
                expect(result.meta.code).to.eql(response.meta.code);
                expect(validator.isLoading).to.be(false);
                done();
            });
            requests[0].respond(200, {'Content-Type': 'application/json'}, JSON.stringify(response));
        });

    });
});


================================================
FILE: src/DGDust/doc/DGDust.md
================================================
## DG.dust

Используется для шаблонизации в Javascript. Использует шаблонизатор [dustjs (fork Linkedin)](http://linkedin.github.io/dustjs/)

### Функция-конструктор

<table>
    <tr>
        <th>Использование</th>
        <th>Возвращает</th>
        <th>Описание</th>
    </tr>
    <tr>
        <td>
            <code><b>String</b><i> name of dust template</i>, <b>Object</b><i> data</i></code>
        </td>
        <td>
            <code><b>String</b><i> rendered template</i></code>
        </td>
        <td>Функция, выполняющая рендер шаблона. Принимает имя шаблона и данные для подстановки и возвращает строку с итоговым html-кодом. Имя шаблона имеет следующий вид: имя_модуля/имя_файла_с_шаблоном; например: DGAttribution/copyright</td>
    </tr>
</table>


### Подключение шаблонов

Добавляем нужные шаблоны в каталог templates:

* **DGTraffic/**
    * **...**
    * **templates/**
        * balloon.dust
        * firmCard.dust

```js
var html = DG.dust('DGTraffic/balloon', {title: 'hello'}) // вернет контент шаблона balloon.dust с подставленым title'ом
```


================================================
FILE: src/DGDust/src/DGDust.js
================================================
var dust = require('dustjs-linkedin');
require('dustjs-helpers');

DG.dust = function(name, data) {
    var result;

    // The callback is called synchronously, so this works
    dust.render(name, data, function(err, html) {
        result = html;
    });

    return result;
};


================================================
FILE: src/DGDust/test/DGDustSpec.js
================================================
describe('DG.Dust', function() {
    it('should be a function', function() {
        expect(DG.dust).to.be.a('function');
    });
});


================================================
FILE: src/DGEntrance/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset='utf-8'>
  <title>DGEntrance demo</title>
  <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>

</head>
<body>

  <div id="map" style="width: 100%; height: 600px; border: 1px solid #ccc;"></div>

  <input class="btn" type="button" value="Найти вход в метро" id="metroEntrance" />
  <input class="btn" type="button" value="Найти вход в остановку" id="busEntrance" />
  <input class="btn" type="button" value="Найти вход в 2GIS" id="dgEntrance" />
  <input class="btn" type="button" value="Погулять и зайти в 2GIS" id="backDgEntrance" />
  <input class="btn" type="button" value="Найти вход в Спарк-Авто" id="sparkAutoEntrance" />
  <input class="btn" type="button" value="Найти вход в ГУМ" id="gumEntrance" />
  <input class="btn" type="button" value="Найти вход в стройку" id="buildingEntrance" />

  <script type="text/javascript">
    var map,
        balloonHTML,
        btns = [
            document.getElementById('metroEntrance'),
            document.getElementById('busEntrance'),
            document.getElementById('dgEntrance'),
            document.getElementById('backDgEntrance'),
            document.getElementById('sparkAutoEntrance'),
            document.getElementById('gumEntrance'),
            document.getElementById('buildingEntrance')
        ];

    DG.then(function () {
        for (var i = 0; i < btns.length; i++) {
            btns[i].onclick = addEntrance;
        };

        map = new DG.Map('map', {
            center: [54.980206086231, 82.898068362003],
            zoom: 18,
            key: DG.config.key || 'Your API access key'
        });
        balloonHTML = '<a href="http://www.2gis.ru/" target="_blank">\n\
            <img src="2gis-logo.png" alt="2GIS" title="2GIS" width="146" height="70" style="border: none"></a>\n\
            <p>Компания «ДубльГИС»</p>Тел.: (383) 363-05-55<br />Адрес: г. Новосибирск, Карла Маркса площадь, 7<br />\n\
            (МФК «Сан Сити»), 13 этаж';
        DG.marker([54.980206086231, 82.898068362003]).addTo(map).bindPopup(balloonHTML).openPopup();

        var entrances = {
            'metroEntrance': new DG.Entrance({
                "vectors": ["LINESTRING(82.89755344390868 54.982320605449296, 82.89714574813843 54.982566865457464, 82.89677560329437 54.9823329184856, 82.89664685726164 54.98240679662398, 82.89677023887634 54.98247451813142)"]
            }),
            'busEntrance': new DG.Entrance({
                "vectors": ["LINESTRING(82.89929687976837 54.98181268941162, 82.89916276931763 54.98173265357113, 82.89852440357208 54.98208665704234)"]
            }),
            'dgEntrance': new DG.Entrance({
                "vectors": ["LINESTRING(82.89850294589996 54.97985176538553, 82.89841711521149 54.97989794209166)"]
            }),

            'backDgEntrance': new DG.Entrance({
                "vectors": ["LINESTRING(82.8998601436615 54.98056903755945, 82.8987979888916 54.98116931987221, 82.89790213108063 54.980658310881815, 82.89726376533508 54.980996932024134, 82.89698481559753 54.98087379739374, 82.89712429046631 54.98043050959726, 82.89719939231873 54.98039664713382, 82.89721012115477 54.98036278464179, 82.89705991744995 54.98028274591077, 82.89718866348267 54.97991333431523, 82.8970867395401 54.97967629341785, 82.89766073226929 54.97944540808143, 82.89810597896576 54.97967013649277, 82.8980040550232 54.97970399956898, 82.89811134338379 54.979771725635736)"]
            }),

            'sparkAutoEntrance': new DG.Entrance({
                "vectors": [
                    "LINESTRING(82.8987067937851 54.97971323494846, 82.89879262447357 54.979667058029875)",
                    "LINESTRING(82.89904475212097 54.97952237000778, 82.89896428585052 54.97956854709275)"
                ]
            }),

            'gumEntrance': new DG.Entrance({
                "vectors": [
                    "LINESTRING(82.8974461555481 54.9816433826377, 82.89768755435944 54.98177574981275, 82.89783239364624 54.9816957138986, 82.89774119853973 54.98164030432612)"
                ]
            }),

            'buildingEntrance': new DG.Entrance({
                "vectors": [
                    "LINESTRING(82.89892673492432 54.98161567782492, 82.89850294589996 54.98136633364934, 82.89860486984253 54.98131400195911)"
                ]
            })

        }

        function addEntrance() {
            var entrance = entrances[this.id];
            entrance.addTo(map).show(true);
        }
    });

    </script>
</body>
</html>


================================================
FILE: src/DGEntrance/src/DGAnimation.js
================================================
/*
 * DG.Animation provides tick (step) logic returning progression values
 * calculated over provided or custom Bézier curves
 * Original input can be array object btw...
 */

DG.Animation = DG.Evented.extend({
    options: {
        // animation: {    //  Or array of objects
        //     function: DG.Animation.EASE,
        //     duration: 2000,
        //     frames: null
        // }

        //offset: 0
        //repeat: 0
    },

    initialize: function(options) {
        DG.setOptions(this, options);

        this._animID = -1;
        this._startTime = 0;
        this._running = false;
        this._animation = null;
        this._durations = null;
    },

    start: function() {
        this.stop();
        this._prepare();

        this._running = true;

        this.fire('start');

        //  Date.now(), but... IE9+
        this._startTime = new Date().getTime();

        this._animate();
    },

    stop: function() {
        if (this._running) {
            this._run(this._durations.getLength());
        }
    },

    _prepare: function() {
        this._animation = DG.Util.isArray(this.options.animation) ? this.options.animation : [this.options.animation];

        this._durations = new DG.Metric.Segments();
        this._animation.forEach(function(animation) {
            this.push(animation.duration);
        }, this._durations);
    },

    _animate: function() {
        this._animID = DG.Util.requestAnimFrame(this._animate, this);
        this._run();
    },

    _run: function(elapsed) {
        var el, index, progress;
        //  Possible skip zero delta time but who cares?!
        elapsed = elapsed ? elapsed : new Date().getTime() - this._startTime;

        if (elapsed < this._durations.getLength()) {
            index = this._durations.getIndex(elapsed);
            el = this._durations.getSegRatio(elapsed);
            progress = this._animation[index]['function'].getYbyX(el);
            this._step(this._getFrameValues(index, progress));
        } else {
            index = this._durations.length - 1;
            this._step(this._getFrameValues(index, 1));
            this._complete();
        }
    },

    _step: function(obj) {
        this.fire('step', obj);
    },

    _complete: function() {
        DG.Util.cancelAnimFrame(this._animID);

        this._durations = null;
        this._animation = null;
        this._running = false;
        this.fire('end');
    },

    _getFrameValues: function(index, progress) {
        var frames = this._animation[index].frames;
        var obj = {progress: progress};
        var fr, to;

        if (frames) {
            for (var key in frames) {
                if (frames[key].progress) {
                    obj[key] = frames[key].progress(progress);
                } else {
                    fr = frames[key].from;
                    to = frames[key].to;
                    obj[key] = fr + (to - fr) * progress;
                }
            }
        }
        return obj;
    }
});

DG.animation = function(options) {
    return new DG.Animation(options);
};

DG.Animation.LINEAR         = new DG.TimeBezier(DG.point(0.00, 0.0), DG.point(1.00, 1.0));
DG.Animation.EASE           = new DG.TimeBezier(DG.point(0.25, 0.1), DG.point(0.25, 1.0));
DG.Animation.EASE_IN        = new DG.TimeBezier(DG.point(0.42, 0.0), DG.point(1.00, 1.0));
DG.Animation.EASE_IN_OUT    = new DG.TimeBezier(DG.point(0.42, 0.0), DG.point(0.58, 1.0));
DG.Animation.EASE_OUT       = new DG.TimeBezier(DG.point(0.00, 0.0), DG.point(0.58, 1.0));


================================================
FILE: src/DGEntrance/src/DGArrowPathTransform.js
================================================
/*
 * DG.ArrowPathTransform class is a core of arrow's body calculations
 *
 * General ideas are:
 *      We construct arrow body with stroke points making arcs on outer path turns
 *      Processing is done segment by segment around {0, 0} virtual point
 *          and resulting 'path' finally rotated to it's original map's angle (.fullAngle)
 *      Subset of this vertices lately used in .subPath() calculations which can be used
 *          in animations for ex.
 *
 *  Final translation (see DG.Entrance.Arrow) moves arrow objects to their original positions
 */

DG.ArrowPathTransform = DG.VertexTransform.extend({
    initialize: function(path) {
        //  'path.offset' is initial points offset (-x / +x) to compensate arrow tip length

        //  Skip super initialization as we need only subset of DG.VertexTransform power
        this._lengths = new DG.Metric.Segments();
        this._vertices = [[], []];
        this._drawings = [[], []];
        //  this._arcs = [];    //  initialized in _setPath()

        this._setPath(path);
        this.subPath(1);
    },

    load: function() {
        return this.subPath(1);
    },

    save: function() {
        return this;    //  NoOp
    },

    //  Method constructs new path points with some displacement from original 'path'
    //  Outer corners will be smoothed by arcs (cubic Bézier curves)
    _setPath: function(path) {
        var transform = DG.ArrowPathTransform.transform;
        var vertices = this._vertices;
        var drawings = this._drawings;
        var Point = DG.Point;
        var width = path.width;
        var arcs = [[], [], []];
        var lengths = [];

        var i, x,
            ax, bx, cx,
            angles, angle;

        vertices.push(path.vertices);   //  expect .pop() in final transform
        vertices[0].push(new DG.Point(path.offset, +width));
        vertices[1].push(new DG.Point(path.offset, -width));
        angles = DG.ArrowPathTransform.getAngles(path);

        cx = -path.offset;
        for (i = 0; i < angles.length; i++) {
            x = path.vertices[i + 1].x;
            ax = width * angles[i].cot;

            //  http://pomax.github.io/bezierinfo/#circles_cubic
            //  actual equation is (4/3 * tan(α/4) * radius)
            bx = angles[i].tan * width * 8 / 3;

            //  Next code can be combined by -/+ inversion but for simplicity it is left as is
            if (ax > 0) {
                vertices[0].push(new Point(x + ax,      +width));
                drawings[0].push('L');

                arcs[2].push(1);
                arcs[1].push(vertices[1].length);
                vertices[1].push(new Point(x + ax,      -width));
                vertices[1].push(new Point(x + ax - bx, -width));

                transform(vertices, angles[i], {x: x, y: 0});

                vertices[1].push(new Point(0 - ax + bx, -width));
                vertices[1].push(new Point(0 - ax,      -width));
                drawings[1].push('L', 'C');

                lengths.push(Math.abs(x + ax) - cx); cx = +ax;
            } else {
                vertices[1].push(new Point(x - ax,      -width));
                drawings[1].push('L');

                arcs[2].push(0);
                arcs[0].push(vertices[0].length);
                vertices[0].push(new Point(x - ax,      +width));
                vertices[0].push(new Point(x - ax + bx, +width));

                transform(vertices, angles[i], {x: x, y: 0});

                vertices[0].push(new Point(0 + ax - bx, +width));
                vertices[0].push(new Point(0 + ax,      +width));
                drawings[0].push('L', 'C');

                lengths.push(Math.abs(x - ax) - cx); cx = -ax;
            }
        }

        //  Final segments and tail arc
        ax = path.vertices[i + 1].x;
        bx = width * 4 / 3; // tan(PI/4) = 1

        vertices[0].push(new Point(ax, +width));
        vertices[1].push(new Point(ax, -width));

        vertices[0].push(new Point(ax - bx, +width));
        vertices[1].push(new Point(ax - bx, -width));

        drawings[0].push('L');
        drawings[1].push('L');

        lengths.push(Math.abs(ax) - cx);

        //  Reverse right path
        vertices[1].reverse();
        drawings[1].reverse();

        //  Move vertices into original position (before last translation)
        angle = DG.VertexTransform.getAnglesSum(angles.fullAngle, path.getAngle());
        transform(vertices, angle, vertices.pop()[0]);  //  path.vertices[0]

        //  We need to reconstruct arc's indexes but too many variables already touched, reuse some of them
        ax = vertices[0].length;
        bx = vertices[1].length;
        this._arcs = arcs[2].map(function(i) {
            cx = arcs[i].shift();
            if (i > 0) {
                return new DG.ArcBezier(vertices[1].slice(bx - cx - 4, bx - cx));
            } else {
                return new DG.ArcBezier(vertices[0].slice(cx, cx + 4).reverse());
            }
        }).reverse();

        this._lengths.push(lengths.pop());
        lengths.reverse().forEach(function(l, i) {
            this._lengths.push(this._arcs[i].getLength()).push(l);
        }, this);

        //  Shortcut border cases (0%-length sub-path and full-path)
        this[0] = {
            vertices: [vertices[0][ax - 2], vertices[0][ax - 1], vertices[1][0], vertices[1][1]],
            drawings: ['M', 'C']
        };
        this[1] = {
            vertices: vertices[0].concat(vertices[1]),
            drawings: ['M'].concat(drawings[0], 'C', drawings[1])
        };
    },

    _setAngleAndDisplacement: function(vL, vR) { // Used in DG.ArrowTipTransform.subShape()
        this.angle = DG.VertexTransform.getAngle({x: vL.x - vR.x, y: vL.y - vR.y}, {x: 0, y: 1});
        this.displ = vR.clone();
    },

    subPath: function(pathRatio) {
        pathRatio = pathRatio > 1 ? 1 : pathRatio;

        //  Shortcut border cases (0%-length sub-path and full-path)
        if (pathRatio === 0 || pathRatio === 1) {
            this.vertices = this[pathRatio].vertices.map(function(vertex) { return vertex.clone(); });
            this.drawings = this[pathRatio].drawings;
            this._setAngleAndDisplacement(this.vertices[0], this.vertices[this.vertices.length - 1]);
            return this;
        }

        var getScaled = DG.VertexTransform.getScaled;
        var vertices = this._vertices;
        var drawings = this._drawings;
        var lengths = this._lengths;
        var len = lengths.getLength() * pathRatio;
        var segIndex = lengths.getIndex(len);
        var segRatio = lengths.getSegRatio(len);
        var vertexIndexLeft = vertices[0].length - 2;
        var vertexIndexRight = 1;
        var drawingIndexLeft = drawings[0].length - 1;
        var drawingIndexRight = 0;
        var vertexLeft, vertexRight;
        var arc = 0, aed = 0;

        while (aed++ < segIndex) {
            if (aed % 2 == 1) {
                vertexIndexLeft--;
                drawingIndexLeft--;
                vertexIndexRight++;
                drawingIndexRight++;
            } else {
                if (drawings[0][drawingIndexLeft] === 'C') {
                    vertexIndexLeft -= 3;
                    drawingIndexLeft -= 1;
                } else {
                    vertexIndexRight += 3;
                    drawingIndexRight += 1;
                }
                arc++;
            }
        }

        if (segIndex % 2 == 1) {
            //  One path ends with an arc
            arc = this._arcs[arc];
            if (drawings[0][drawingIndexLeft] === 'C') {
                arc = arc.getCurveBefore(arc.getTbyL(lengths.getSegLength(len)));
                vertexLeft = arc.points[3];
                vertexRight = vertices[1][vertexIndexRight];
                this.vertices = arc.points.slice(1).reverse()
                    .concat(vertices[0].slice(vertexIndexLeft), vertices[1].slice(0, vertexIndexRight + 1))
                    .map(function(vertex) { return vertex.clone(); });
                this.drawings = ['M'].concat(drawings[0].slice(drawingIndexLeft), 'C', drawings[1].slice(0, drawingIndexRight));
            } else {
                arc = arc.getCurveBefore(arc.getTbyL(lengths.getSegLength(len)));
                vertexLeft = vertices[0][vertexIndexLeft];
                vertexRight = arc.points[3];
                this.vertices = vertices[0].slice(vertexIndexLeft)
                    .concat(vertices[1].slice(0, vertexIndexRight + 1), arc.points.slice(1))
                    .map(function(vertex) { return vertex.clone(); });
                this.drawings = ['M'].concat(drawings[0].slice(drawingIndexLeft + 1), 'C', drawings[1].slice(0, drawingIndexRight + 1));
            }
        } else {
            //  Both paths end with lines
            vertexLeft = getScaled(vertices[0][vertexIndexLeft], vertices[0][vertexIndexLeft - 1], segRatio);
            vertexRight = getScaled(vertices[1][vertexIndexRight], vertices[1][vertexIndexRight + 1], segRatio);
            this.vertices = [vertexLeft]
                .concat(vertices[0].slice(vertexIndexLeft), vertices[1].slice(0, vertexIndexRight + 1), vertexRight)
                .map(function(vertex) { return vertex.clone(); });
            this.drawings = ['M'].concat(drawings[0].slice(drawingIndexLeft), 'C', drawings[1].slice(0, drawingIndexRight + 1));
        }

        this._setAngleAndDisplacement(vertexLeft, vertexRight);
        return this;
    },

    statics: {
        getAngles: function(path) {
            var getAngle = DG.VertexTransform.getAngle;
            var fullAngle = {cos: 1, sin: 0};
            var vertices = path.vertices;
            var angles = [];

            var absSin, angle,
                cos, sin, cot, temp, sign;

            for (var i = 1, len = vertices.length - 1; i < len; i++) {
                angle = getAngle(vertices[i - 1], vertices[i + 1], vertices[i]);

                absSin = Math.abs(angle.sin);
                if (absSin < 0.000001) {
                    //  Exclude 180° angle from vertices array
                    vertices.splice(vertices.length - i - 1, 1);
                    len--;
                    i--;
                } else {
                    //  This is half ∢α cotangent, sign describes angle direction and used to shortcut stroke calculations
                    //  '-1' - right angle is inner angle, '1' - left angle is inner angle (if seen from [0, 0] to [-1, 0])
                    angle.cot = (1 + angle.cos) / angle.sin;

                    //  We need to rotate next segment to [-1, 0] axis, so we need complementary angle actually
                    angle.cos = -angle.cos;

                    //  Complimentary angle also used to calculate it's quaternary ∢β tangent
                    //  ∢β tangent used in approximation of outer arc segment by Bézier curve
                    cot = (1 + angle.cos) / angle.sin;
                    sign = cot < 0 ? -1 : 1;
                    temp = sign * Math.sqrt(4 * cot * cot + 4);
                    angle.tan = -0.5 * (cot + cot - temp);

                    angles.push(angle);

                    cos = fullAngle.cos * angle.cos - fullAngle.sin * angle.sin;
                    sin = fullAngle.sin * angle.cos + fullAngle.cos * angle.sin;

                    fullAngle = {cos: cos, sin: sin};
                }
            }

            //  Used in final stroke points translation
            angles.fullAngle =  {cos: fullAngle.cos, sin: -fullAngle.sin};
            return angles;
        },

        //  TODO - if length of 'latlngs' array is less than 2 or it is undefined next function produces exception
        //  check this condition in outer routines?!
        getTranslatedPath: function(map, latlngs) {
            var path = new DG.VertexTransform([]);
            var i = latlngs.length - 1;
            var v = map.project(latlngs[i]);
            var dx = v.x, dy = v.y;

            path.vertices.push(new DG.Point(0, 0));
            while (i--) {
                v = map.project(latlngs[i]);
                path.vertices.push(new DG.Point(v.x - dx, v.y - dy));
            }
            return path
                .setAngle(DG.VertexTransform.getAngle(-path.vertices[1].x, -path.vertices[1].y))
                .unRotate();
        },

        transform: function(rings, angle, vector) {
            var i = rings.length;
            var cos = angle.cos;
            var sin = angle.sin;
            var dx = vector.x;
            var dy = vector.y;
            var ring, x, y, j;

            while (i--) {
                ring = rings[i];
                j = ring.length;
                while (j--) {
                    x = ring[j].x - dx;
                    y = ring[j].y - dy;
                    ring[j].x = x * cos - y * sin;
                    ring[j].y = x * sin + y * cos;
                }
            }
        }
    }
});


================================================
FILE: src/DGEntrance/src/DGArrowTipTransform.js
================================================
/*
 * DG.ArrowTipTransform class is a core of arrow's tip calculations
 *
 * .subShape() routine 'bound' arrow's tip to the ending points of .subPath()
 * calculated separately in DG.ArrowPathTransform
 *
 *  Final translation (see DG.Entrance.Arrow) moves arrow objects to their original positions
 */

DG.ArrowTipTransform = DG.VertexTransform.extend({
    initialize: function(path, shape) {
        this.drawings = shape.drawings; //  static mapping
        this._vertices = shape.vertices;

        this._setShape(path, shape);
    },

    _setShape: function(path, shape) {
        var sp = shape.vertices[0];
        var width = Math.abs(sp.y);
        var pl = path.vertices[1].x;    //  negative value
        var length = sp.x;              //  negative value
        var offset = pl - length + width + width;

        path.width = width;
        path.offset = length + (offset > 0 ? offset : 0);
        if (path.vertices.length < 3 && length > -10) {
            path.offset += 2.5;
        }

        this._vertices = this.load().unTranslate(sp).vertices;
    },

    subShape: function(transform) {
        this.load().unRotate(transform.angle).translate(transform.displ);
        return this;
    }
});


================================================
FILE: src/DGEntrance/src/DGBezierCurves.js
================================================
/*
 * DGBezierCurves is a collection of three classes:
 * Original DG.Bezier class provides basic math for Cubic and Quadratic Bézier curves
 * DG.TimeBezier used in animation effects it can return 'Distance' (Y) by Time (X) value
 * DG.ArcBezier can return 't' value by curve's segment length
 * Actual calculations can be very hard (in math terms) so we use LUT's to optimize them
 *
 * Original ideas come from this source:   https://pomax.github.io/bezierinfo/
 */

DG.Bezier = DG.Class.extend({
    /**
     * Initialize curve object by provided control points
     * @param {Array<DG.Point>} coords Curve's control points in DG.Point format (up to four control points supported)
     * @param {boolean} [clone] Clone original points or not (Default)
     */
    initialize: function(coords, clone) {
        if (clone) {
            this.points = coords.map(function(coord) { return coord.clone(); });
        } else {
            this.points = coords;
        }
        this.dpoints = this._getDerivatives();
        this.order = this.points.length - 1;
        this._lut = [];
    },

    getPoint: function(t) {
        var p = this.points;
        var mt, mt2, t2;
        var a, b, c, d;

        if (t === 0) { return p[0]; }
        if (t === 1) { return p[this.order]; }

        mt = 1 - t;
        mt2 = mt * mt;
        t2 = t * t;

        if (this.order > 2) {
            a = mt2 * mt;
            b = mt2 * t * 3;
            c = mt * t2 * 3;
            d = t * t2;
        } else {
            p = [p[0], p[1], p[2], {x: 0, y: 0}];
            a = mt2;
            b = mt * t * 2;
            c = t2;
            d = 0;
        }

        return new DG.Point(
            a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,
            a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y
        );
    },

    derivative: function(t) {
        var p = this.dpoints[0];
        var mt = 1 - t;
        var a, b, c;

        if (this.order > 2) {
            a = mt * mt;
            b = mt * t * 2;
            c = t * t;
        } else {
            p = [p[0], p[1], {x: 0, y: 0}];
            a = mt; b = t; c = 0;
        }

        return new DG.Point(
            a * p[0].x + b * p[1].x + c * p[2].x,
            a * p[0].y + b * p[1].y + c * p[2].y
        );
    },

    getLength: function() {
        /* eslint-disable camelcase */
        var w_i = DG.Bezier.WEIGHT;
        var x_i = DG.Bezier.ABSCISSA;
        var z = 0.5;
        var sum = 0;
        var d, l, t;

        for (var i = 0; i < x_i.length; i++) {
            t = z * x_i[i] + z;
            d = this.derivative(t);
            l = d.x * d.x + d.y * d.y;
            sum += w_i[i] * Math.sqrt(l);
        }
        /* eslint-enable camelcase */

        return z * sum;
    },

    getCurveBefore: function(z) {
        var p = this.points;
        var z2, z3, mz, mz2, mz3;
        var b$3, b$4, c$4;
        var curve;

        if (z === 1) { return this.clone(); }

        curve = [];
        z2 = z * z;
        mz = z - 1;
        mz2 = mz * mz;

        curve[0] = new DG.Point(
            p[0].x,
            p[0].y
        );

        curve[1] = new DG.Point(
            z * p[1].x - mz * p[0].x,
            z * p[1].y - mz * p[0].y
        );

        b$3 = z * mz * 2;
        curve[2] = new DG.Point(
            z2 * p[2].x - b$3 * p[1].x + mz2 * p[0].x,
            z2 * p[2].y - b$3 * p[1].y + mz2 * p[0].y
        );

        if (this.order > 2) {
            z3 = z2 * z;
            mz3 = mz2 * mz;
            b$4 = z2 * mz * 3;
            c$4 = z * mz2 * 3;
            curve[3] = new DG.Point(
                z3 * p[3].x - b$4 * p[2].x + c$4 * p[1].x - mz3 * p[0].x,
                z3 * p[3].y - b$4 * p[2].y + c$4 * p[1].y - mz3 * p[0].y
            );
        }

        return new DG.Bezier(curve);
    },

    getCurveAfter: function(z) {
        var p = this.points;
        var n = this.order;
        var z2, z3, mz, mz2, mz3;
        var b$3, b$4, c$4;
        var curve;

        if (z === 1) { return this.clone(); }

        curve = [];
        z2 = z * z;
        mz = z - 1;
        mz2 = mz * mz;

        curve[n] = new DG.Point(
            p[n].x,
            p[n].y
        );

        curve[--n] = new DG.Point(
            z * p[n + 1].x - mz * p[n].x,
            z * p[n + 1].y - mz * p[n].y
        );

        b$3 = z * mz * 2;
        curve[--n] = new DG.Point(
            z2 * p[n + 2].x - b$3 * p[n + 1].x + mz2 * p[n].x,
            z2 * p[n + 2].y - b$3 * p[n + 1].y + mz2 * p[n].y
        );

        if (this.order > 2) {
            z3 = z2 * z;
            mz3 = mz2 * mz;
            b$4 = z2 * mz * 3;
            c$4 = z * mz2 * 3;
            curve[--n] = new DG.Point(
                z3 * p[n + 3].x - b$4 * p[n + 2].x + c$4 * p[n + 1].x - mz3 * p[n].x,
                z3 * p[n + 3].y - b$4 * p[n + 2].y + c$4 * p[n + 1].y - mz3 * p[n].y
            );
        }

        return new DG.Bezier(curve);
    },

    _getDerivatives: function() {
        var p = this.points;
        var d, c, j, list;
        var result = [];

        for (d = p.length, c = d - 1; d > 1; d--, c--) {
            list = [];
            for (j = 0; j < c; j++) {
                list.push(new DG.Point(
                    c * (p[j + 1].x - p[j].x),
                    c * (p[j + 1].y - p[j].y)
                ));
            }
            result.push(list);
            p = list;
        }

        return result;
    },

    getLUT: function(steps) {
        steps = steps || 125;

        if (this._lut.length !== steps + 1) {
            if (this.order > 2) {
                this._setLUT3(steps);
            } else {
                this._setLUT2(steps);
            }
        }

        return this._lut;
    },

    _setLUT2: function(steps) {
        var lut = this._lut = [];
        var p = this.points;
        var t, mt;
        var a, b, c;

        lut.push({x: p[0].x, y: p[0].y, l: 0});
        for (var s = 1; s < steps; s++) {
            t = s / steps;
            mt = 1 - t;
            a = mt * mt;
            b = mt * t * 2;
            c = t * t;
            lut.push({
                x: a * p[0].x + b * p[1].x + c * p[2].x,
                y: a * p[0].y + b * p[1].y + c * p[2].y
            });
        }
        lut.push({x: p[2].x, y: p[2].y, l: 0});
    },

    _setLUT3: function(steps) {
        var lut = this._lut = [];
        var p = this.points;
        var t, t2, mt, mt2;
        var a, b, c, d;

        lut.push({x: p[0].x, y: p[0].y, l: 0});
        for (var s = 1; s < steps; s++) {
            t = s / steps;
            mt = 1 - t;
            mt2 = mt * mt;
            t2 = t * t;
            a = mt2 * mt;
            b = mt2 * t * 3;
            c = mt * t2 * 3;
            d = t * t2;
            lut.push({
                x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,
                y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y
            });
        }
        lut.push({x: p[3].x, y: p[3].y, l: 0});
    },

    clone: function() {
        return new DG.Bezier(this.points, true);
    }
});

DG.bezier = function(coords) {
    if (typeof coords === 'number' || coords instanceof DG.Point) {
        coords = Array.prototype.slice.call(arguments);
    }

    if (typeof coords[0] === 'number') {
        if (coords.length < 7) {
            coords = [
                new DG.Point(coords[0], coords[1]),
                new DG.Point(coords[2], coords[3]),
                new DG.Point(coords[4], coords[5])
            ];
        } else {
            coords = [
                new DG.Point(coords[0], coords[1]),
                new DG.Point(coords[2], coords[3]),
                new DG.Point(coords[4], coords[5]),
                new DG.Point(coords[6], coords[7])
            ];
        }
        return new DG.Bezier(coords);
    } else {
        return new DG.Bezier(coords, true);
    }
};

/* eslint-disable indent */
DG.Bezier.WEIGHT = [
    0.3626837833783620,
    0.3626837833783620,
    0.3137066458778873,
    0.3137066458778873,
    0.2223810344533745,
    0.2223810344533745,
    0.1012285362903763,
    0.1012285362903763
];
DG.Bezier.ABSCISSA = [
   -0.1834346424956498,
    0.1834346424956498,
   -0.5255324099163290,
    0.5255324099163290,
   -0.7966664774136267,
    0.7966664774136267,
   -0.9602898564975363,
    0.9602898564975363
];
/* eslint-enable indent */


//  This curve is monotonically ordered by 'X' coordinate and has P[0] = {0, 0} and P[3] = {1, 1}
//  We can utilize this facts to shortcut calculations
DG.TimeBezier = DG.Bezier.extend({
    initialize: function(controlPoint1, controlPoint2, clone) {
        DG.Bezier.prototype.initialize.call(
            this,
            [DG.TimeBezier.START, controlPoint1, controlPoint2, DG.TimeBezier.END],
            clone
        );
    },

    getYbyX: function(x) {
        var lut = this.getLUT();
        var max = lut.length - 1;
        var min = 0;
        var mid;

        if (x <= 0) { return 0; }
        if (x >= 1) { return 1; }

        //  'X' is monotonically increasing so we can do a simple binary search (LUT)
        //  and then fine-tune the result by linear interpolation assuming 'Y' is not changed so radically
        while (true) {
            mid = min + (max - min >> 1);
            if (x < lut[mid].x) {
                max = mid;
            } else {
                min = mid;
            }
            if (max - min < 2) { break; }
        }
        x = (x - lut[min].x) / (lut[max].x - lut[min].x);

        return (lut[min].y + (lut[max].y - lut[min].y) * x);
    },

    getLUT: function(steps) {
        var p = this.points;
        var t, t2, mt;
        var b, c, d;
        var lut;

        steps = steps || 240;
        if (this._lut.length === steps + 1) {
            return this._lut;
        } else {
            this._lut = lut = [];
        }

        lut.push({x: 0, y: 0});
        for (var s = 1; s < steps; s++) {
            t = s / steps;
            mt = 1 - t;
            t2 = t * t;
            //  We don't need 'a' coefficient because p[0] is {0, 0}
            b = mt * mt * t * 3;
            c = mt * t2 * 3;
            d = t * t2;
            lut.push({
                x: b * p[1].x + c * p[2].x + d,
                y: b * p[1].y + c * p[2].y + d
            });
        }
        lut.push({x: 1, y: 1});

        return lut;
    },

    clone: function() {
        return new DG.TimeBezier(this.points, true);
    }
});

DG.TimeBezier.START = DG.point(0, 0);
DG.TimeBezier.END = DG.point(1, 1);


//  This is cubic Bezier describing circular arc
DG.ArcBezier = DG.Bezier.extend({
    initialize: function(coords, clone) {
        DG.Bezier.prototype.initialize.call(this, coords, clone);
        this.getLUT();
        this._setLutLengths();
    },

    getTbyL: function(l) {
        var lut = this.getLUT();
        var max = lut.length - 1;
        var min = 0;
        var mid;
        var x, y;

        if (l <= 0) { return 0; }
        if (l >= lut[max].l) { return 1; }

        //  'L' is monotonically increasing so we can do a binary search (LUT)
        //  and then fine-tune the result by linear interpolation
        while (true) {
            mid = min + (max - min >> 1);
            if (l < lut[mid].l) {
                max = mid;
            } else {
                min = mid;
            }
            if (max - min < 2) { break; }
        }
        l = (l - lut[min].l) / (lut[max].l - lut[min].l);

        x = (lut[min].x + (lut[max].x - lut[min].x) * l);
        y = (lut[min].y + (lut[max].y - lut[min].y) * l);

        //  BUT this is a part of story, we need a projection of this point to the actual curve and it's reverse 't' val
        var p, dx, dy, t;
        var et = max / lut.length;
        var dt = min / lut.length;
        var s = 1 / lut.length / 10;    //  TODO
        var d = Math.pow(2, 53) - 1;

        for (t = dt; dt < et; dt += s) {
            p = this.getPoint(dt);
            dx = p.x - x; dy = p.y - y;
            l = Math.sqrt(dx * dx + dy * dy);
            if (l < d) {
                d = l;
                t = dt;
            }
        }

        return t;
    },

    _setLutLengths: function() {
        var lut = this._lut;
        var dx, dy;

        lut[0].l = 0;
        for (var i = 1; i < lut.length; i++) {
            dx = lut[i].x - lut[i - 1].x;
            dy = lut[i].y - lut[i - 1].y;
            lut[i].l = lut[i - 1].l + Math.sqrt(dx * dx + dy * dy);
        }
    },

    getLength: function() {
        return this._lut[this._lut.length - 1].l;
    },

    clone: function() {
        return new DG.ArcBezier(this.points, true);
    }
});


================================================
FILE: src/DGEntrance/src/DGComplexPath.js
================================================
/*
 * DG.ComplexPath is a simple vector layer class with empty .getEvents() object(!)
 * It's drawing logic is maintained in DG.Entrance.Arrow class
 *
 * _pxBounds is a pixel bounds of this drawings and they are used in L.Canvas
 */

DG.ComplexPath = DG.Path.extend({
    options: {
        fill: true,
        fillOpacity: 1,
        interactive: false
    },

    initialize: function(options) {
        DG.setOptions(this, options);

        this._empty = [];

        this._pxEmpty = DG.bounds(
            DG.point(0, 0), DG.point(0, 0)
        );
        this._pxBounds = this._pxEmpty;

        this._vertices = [this._empty];
        this._drawings = [this._empty];
    },

    getEvents: function() {
        return {};
    },

    _project: function() {
        var opts = this.options,
            zoom, weight;

        if (this._map) {
            zoom = this._map.getZoom();
        } else {
            return;
        }

        if (opts.visibility.isShown && opts.transform[zoom]) {
            //  Next numbers was empirically selected in order to provide visual compliance
            //  to the original arrow's implementation
            weight = 2.2 - ((19 - zoom) * 0.2);
            if (opts.weight !== weight) {
                this.setStyle({weight: +weight.toFixed(2)});
            }

            this._vertices[0] = opts.transform[zoom].vertices;
            this._drawings[0] = opts.transform[zoom].drawings;

            this._pxBounds = opts.transform[zoom]._pxBounds;
        } else {
            this._vertices[0] = this._empty;
            this._drawings[0] = this._empty;

            this._pxBounds = this._pxEmpty;
        }
    },

    _update: function() {
        if (this._map) {
            this._updatePath();
        }
    },

    _updatePath: function() {  //  used in Canvas renderer
        this._renderer._updateComplexPath(this);
    }
});


================================================
FILE: src/DGEntrance/src/DGEntrance.js
================================================
/*
 * DG.Entrance is a main class that hosts actual arrow layers
 * It orchestrates animation and provides user space methods like .show() and .hide()
 */

DG.Entrance = DG.FeatureGroup.extend({

    options: {
        vectors: [],

        fillColor: '#0085a0',
        strokeColor: '#fff',

        enableAnimation: true,
        interactive: false,

        autoClose: true
    },

    initialize: function(options) {
        DG.LayerGroup.prototype.initialize.call(this);

        DG.setOptions(this, options);

        this._bounds =
            new DG.LatLngBounds();
        this._animations = {
            bounce: DG.animation(DG.Entrance.BOUNCE_ANIMATION),
            path: DG.animation(DG.Entrance.PATH_ANIMATION)
        };

        this._initArrows();

        this._isShown = false;
    },

    onAdd: function(map) {
        DG.LayerGroup.prototype.onAdd.call(this, map);
        this.show();
    },

    onRemove: function(map) {
        this.hide();
        DG.LayerGroup.prototype.onRemove.call(this, map);
    },

    getEvents: function() {
        var events = {};

        if (this.options.autoClose) {
            events['layeradd'] = this._removeEntrance;  //  eslint-disable-line dot-notation
        }
        if (this.options.enableAnimation) {
            events['zoomend'] = this._animate;          //  eslint-disable-line dot-notation
        }

        return events;
    },

    show: function(fitBounds) {
        if (this._layers) {
            if (fitBounds) {
                this.fitBounds();
            }
            if (!this._isShown) {
                this._isShown = true;
                this.eachLayer(function(arrow) {
                    arrow.setVisibility(true);
                });
                if (this.options.enableAnimation) {
                    this._animate();
                }
                this._map.fire('entranceshow');
            }
        }

        return this;
    },

    hide: function() {
        if (this._layers && this._isShown) {
            this._isShown = false;
            this.eachLayer(function(arrow) {
                arrow.setVisibility(false);
            });
            this._map.fire('entrancehide');
        }

        return this;
    },

    isShown: function() {
        return this._isShown;
    },

    getBounds: function() {
        return this._bounds;
    },

    setFillColor: function(color) {
        this.eachLayer(function(arrow) {
            arrow.setStyle({fillColor: color});
        });
    },

    setStrokeColor: function(color) {
        this.eachLayer(function(arrow) {
            arrow.setStyle({color: color});
        });
    },

    _initArrows: function() {
        var base = {
            color: this.options.strokeColor,
            fillColor: this.options.fillColor,
            interactive: this.options.interactive
        };

        this.options.vectors
            .map(function(vector) {
                return DG.Wkt.toLatLngs(vector);
            })
            .forEach(function(latlngs) {
                var options = DG.Util.create(base),
                    bounds = DG.latLngBounds(latlngs);

                this._bounds.extend(bounds);

                options.latlngs = latlngs;
                options.bounds = bounds;
                if (this.options.enableAnimation) {
                    if (latlngs.length > 2) {
                        options.animation = this._animations.path;
                    } else {
                        options.animation = this._animations.bounce;
                        options.distance = true;
                    }
                }

                this.addLayer(DG.entrance.arrow(options));
            }, this);
    },


    _animate: function() {
        if (this._isShown) {
            this._animations.bounce.start();
            this._animations.path.start();
        }
    },

    //  Current logic of next four methods extracted from original arrow's implementation
    fitBounds: function() {
        var map = this._map, fitZoom,
            bounds = this.getBounds();

        if (!map.getBounds().contains(bounds) || !this._isAllowedZoom()) {
            fitZoom = this._getFitZoom();
            if (!map.projectDetector.getProject()) {
                map.once('moveend', function() {
                    map.setZoom(this._getFitZoom());
                }, this);
            }
            map.setView(bounds.getCenter(), fitZoom, {animate: true});
        }

        return this;
    },

    _getFitZoom: function() {
        var project = this._map.projectDetector.getProject();
        return project ? project.maxZoom : DG.Entrance.SHOW_FROM_ZOOM;
    },

    _isAllowedZoom: function() {
        return this._map.getZoom() >= DG.Entrance.SHOW_FROM_ZOOM;
    },

    _removeEntrance: function(e) {
        if (e.layer instanceof DG.Popup ||
            (e.layer instanceof DG.Entrance && e.layer !== this)) {

            this.remove();
        }
    }
});

DG.entrance = function(options) {
    return new DG.Entrance(options);
};

DG.Entrance.SHOW_FROM_ZOOM = 16;
DG.Entrance.PATH_ANIMATION = {
    animation: {
        'function': DG.Animation.EASE_IN_OUT,
        'duration': 750
    }
};
DG.Entrance.BOUNCE_ANIMATION = {
    animation: [
        {'function': DG.Animation.EASE_IN_OUT, 'duration': 250, 'frames': {'distance': {'from': 0, 'to': 0.6}}},
        {'function': DG.Animation.EASE_IN, 'duration': 135, 'frames': {'distance': {'from': 0.6, 'to': 0}}},
        {'function': DG.Animation.EASE_OUT, 'duration': 135, 'frames': {'distance': {'from': 0, 'to': 0.16}}},
        {'function': DG.Animation.EASE_IN, 'duration': 90, 'frames': {'distance': {'from': 0.16, 'to': 0}}},
        {'function': DG.Animation.EASE_OUT, 'duration': 90, 'frames': {'distance': {'from': 0, 'to': 0.06}}},
        {'function': DG.Animation.EASE_IN, 'duration': 50, 'frames': {'distance': {'from': 0.06, 'to': 0}}}
    ]
};


================================================
FILE: src/DGEntrance/src/DGEntranceArrow.js
================================================
/*
 * DG.Entrance.Arrow class hosts two layers, one for arrow body (path) and one for arrow tip
 * It overrides projection events from hosted layers to minimize total overhead
 * Actual calculations produced in DG.ArrowPathTransform and DG.ArrowTipTransform classes
 */

DG.Entrance.Arrow = DG.FeatureGroup.extend({
    initialize: function(options) {
        DG.LayerGroup.prototype.initialize.call(this);

        DG.setOptions(this, options);

        this._progress = 1;
        this._distance = 0;
        this._visibility = {
            isShown: false
        };
        this._position =
            options.latlngs[options.latlngs.length - 1];
        this._shape =
            this.options.shape ||
            DG.Entrance.Arrow.SHAPE;

        this._apt = {}; // DG.ArrowPathTransform objects by zoom levels
        this._att = {}; // DG.ArrowTipTransform objects by zoom levels
    },

    beforeAdd: function(map) {
        //  this._map is not initialized yet, so we can freely addLayer(s)
        var opts = this.options;

        //  TODO: Check Canvas processing order
        //  Additional logic to DISABLE animation on Canvas for now!
        if (opts.animation && !map.options.preferCanvas && !DG.Browser.ielt9) {
            opts.animation.on('step', this._animation, this);
        } else {
            opts.animation = null;
        }

        this.projection();

        this.addLayer(new DG.ComplexPath({
            lineCap: 'butt',
            color: opts.color,
            fillColor: opts.fillColor,
            interactive: opts.interactive,
            visibility: this._visibility,
            transform: this._apt
        }));

        this.addLayer(new DG.ComplexPath({
            lineJoin: 'miter',
            color: opts.color,
            fillColor: opts.fillColor,
            interactive: opts.interactive,
            visibility: this._visibility,
            transform: this._att
        }));
    },

    getEvents: function() {
        return {
            zoomend: this._project,
            moveend: this._update,
            viewreset: this._reset
        };
    },

    setVisibility: function(isShown) {
        if (this._visibility.isShown !== isShown) {
            this._visibility.isShown = isShown;
            if (isShown) {
                if (!this.options.animation) {
                    this._reset();
                }
            } else {
                this._reset();
            }
        }
    },

    getBounds: function() {
        return this.options.bounds;
    },

    projection: function() {
        var map = this._map || this._mapToAdd;
        var zoom = map ? map.getZoom() : 0;
        var vertices = this._shape.vertices[zoom];
        var drawings = this._shape.drawings[zoom];
        var latlngs = this.options.latlngs;
        var shape, path, lastPoint, prevPoint;

        if (zoom && vertices && drawings) {
            if (!this._att[zoom]) {
                path = DG.ArrowPathTransform.getTranslatedPath(map, latlngs);
                shape = {vertices: vertices, drawings: drawings};
                this._att[zoom] = new DG.ArrowTipTransform(path, shape);
                this._apt[zoom] = new DG.ArrowPathTransform(path);
            }

            lastPoint = map.latLngToLayerPoint(this._position);
            prevPoint = map.latLngToLayerPoint(latlngs[latlngs.length - 2]);
            if (!this._apt[zoom]._pxBounds) {
                //  One-time action per 'viewreset' event
                //  Caching _pxBounds for using with Canvas renderer
                this._setBounds(lastPoint, prevPoint, this._apt[zoom], this._att[zoom]);
            }
            if (this.options.distance) {
                //  Arrow position recalculated for Bounce animation effect
                lastPoint = DG.VertexTransform.getScaled(lastPoint, prevPoint, this._distance);
            }

            //  Main calculations
            //  Get part of the arrow path and move (bound) arrow tip to it
            this._apt[zoom].subPath(this._progress).translate(lastPoint);
            this._att[zoom].subShape(this._apt[zoom]).translate(lastPoint);
        }

        return this;
    },

    _animation: function(e) {
        if (e.distance != undefined) {
            this._distance = e.distance;    //  bounce animation effect
        } else {
            this._progress = e.progress;    //  path animation effect
        }
        if (this._visibility.isShown) {
            //  TODO: Additional logic for animation on Canvas
            // this.projection().invoke('redraw');

            this._project();
            this._update();
        }
    },

    _project: function() {
        this.projection().invoke('_project');
    },

    _update: function() {
        this.invoke('_update');
    },

    _reset: function() {
        this._resetBounds();

        this._project();
        this._update();
    },

    _resetBounds: function() {
        //  Canvas renderer specific
        var z;

        for (z in this._apt) {
            this._apt[z]._pxBounds = null;
        }

        for (z in this._att) {
            this._att[z]._pxBounds = null;
        }
    },

    _setBounds: function(pl, pp, apt, att) {
        var _apt = apt.subPath(1).translate(pl).vertices,
            _att = att.subShape(apt).translate(pl).vertices;

        //  TODO: Additional logic for animation on Canvas
        // if (this.options.distance) {
        //     pl = DG.VertexTransform.getScaled(pl, pp, 1);
        //     _apt = _apt.concat(apt.subPath(1).translate(pl).vertices);
        //     _att = _att.concat(att.subShape(apt).translate(pl).vertices);
        // }

        apt._pxBounds = new DG.Bounds(_apt);
        att._pxBounds = new DG.Bounds(_att);
    }
});

DG.entrance.arrow = function(options) {
    return new DG.Entrance.Arrow(options);
};


================================================
FILE: src/DGEntrance/src/DGEntranceArrowShape.js
================================================
/*
 * Predefined arrow tips
 */

/* eslint-disable array-bracket-spacing */
DG.Entrance.Arrow.SHAPE = {
    vertices: {
        16: [
            [ -6.5000,  -1.8000],
            [ -6.0522,  -1.8000],
            [ -7.0975,  -5.2537],
            [ -6.6619,  -6.2565], [ -6.5980,  -6.3550], [ -6.1757,  -6.1470],
            [  0.8371,  -0.3552],
            [  0.9275,  -0.1764], [  0.9275,   0.1764], [  0.8371,   0.3552],
            [ -6.1757,   6.1470],
            [ -6.5980,   6.3550], [ -6.6619,   6.2565], [ -7.0975,   5.2537],
            [ -6.0522,   1.8000],
            [ -6.5000,   1.8000]
        ],
        17: [
            [ -9.0000,  -2.4000],
            [ -7.8890,  -2.4000],
            [ -9.9245,  -7.2548],
            [ -9.3363,  -8.6404], [ -9.3448,  -8.6448], [ -8.8717,  -8.3508],
            [  1.0285,  -0.3552],
            [  1.1190,  -0.1764], [  1.1190,   0.1764], [  1.0285,   0.3552],
            [ -8.8717,   8.3508],
            [ -9.3448,   8.6448], [ -9.3363,   8.6404], [ -9.9245,   7.2548],
            [ -7.8890,   2.4000],
            [ -9.0000,   2.4000]
        ],
        18: [
            [-11.5000,  -3.0000],
            [-10.0795,  -3.0000],
            [-12.4909,  -9.3173],
            [-11.8402, -10.7654], [-11.5986, -10.7073], [-10.9380, -10.2258],
            [  1.1497,  -0.3552],
            [  1.2402,  -0.1764], [  1.2402,   0.1764], [  1.1497,   0.3552],
            [-10.9380,  10.2258],
            [-11.5986,  10.7073], [-11.8402,  10.7654], [-12.4909,   9.3173],
            [-10.0795,   3.0000],
            [-11.5000,   3.0000]
        ],
        19: [
            [-13.0000,  -3.6000],
            [-11.6600,  -3.6000],
            [-14.1696, -10.8351],
            [-13.5189, -12.2832], [-13.2773, -12.2251], [-12.6167, -11.7436],
            [  1.3061,  -0.3552],
            [  1.3966,  -0.1764], [  1.3966,   0.1764], [  1.3061,   0.3552],
            [-12.6167,  11.7436],
            [-13.2773,  12.2251], [-13.5189,  12.2832], [-14.1696,  10.8351],
            [-11.6600,   3.6000],
            [-13.0000,   3.6000]
        ]
    },
    drawings: {
        16: ['M', 'L', 'L', 'C', 'L', 'C', 'L', 'C', 'L', 'L'],
        17: ['M', 'L', 'L', 'C', 'L', 'C', 'L', 'C', 'L', 'L'],
        18: ['M', 'L', 'L', 'C', 'L', 'C', 'L', 'C', 'L', 'L'],
        19: ['M', 'L', 'L', 'C', 'L', 'C', 'L', 'C', 'L', 'L']
    }
};
/* eslint-enable array-bracket-spacing */


(function(vertices) {
    for (var i in vertices) {
        vertices[i] = vertices[i].map(function(vertex) { return DG.point(vertex); });
    }
})(DG.Entrance.Arrow.SHAPE.vertices);


================================================
FILE: src/DGEntrance/src/DGMetric.js
================================================
/*
 * Utility functions
 */

DG.Metric = function() {};

/*
 * DG.Metric.Segments class can calculate total pushed segments length and used to shortcut
 * 'get Something by provided Length' calculations (segment's Index, segment's Length, etc...)
 */
DG.Metric.Segments = function() {
    this.length = 0;
};

DG.Metric.Segments.prototype = {
    push: function(len) {
        this[this.length] = this.length > 0 ? this[this.length - 1] + len : len;
        this.length += 1;

        return this;
    },

    getLength: function() {
        return this[this.length - 1];
    },

    getReverse: function() {
        var segments = new DG.Metric.Segments();
        var i = this.length - 1;

        if (i < 0) { return segments; }

        while (i--) {
            segments.push(this[i + 1] - this[i]);
        }

        return segments.push(this[0]);
    },

    getIndex: function(len) {
        var i = this.length - 1;

        if (i < 0) { return i; }

        while (i--) {
            if (this[i] <= len) { break; }
        }

        return i + 1;
    },

    getSegRatio: function(len) {
        var i = this.getIndex(len);
        var sub = i > 0 ? this[i - 1] : 0;

        return (len - sub) / (this[i] - sub);
    },

    getSegLength: function(len) {
        var i = this.getIndex(len);
        var sub = i > 0 ? this[i - 1] : 0;

        return len - sub;
    }
};


================================================
FILE: src/DGEntrance/src/DGRenderer.js
================================================
/*
 * Actual painting methods that can draw complex objects with curves
 *
 * Point coordinates must be provided in layer._vertices object
 * And types of line must be provided in layer._drawings object
 */

DG.extend(L.Canvas.prototype, {
    _updateComplexPath: function(layer, closed) {
        var i, j, k, d, x, y, _x, _y, $x, $y, points;
        var drawings = layer._drawings;
        var vertices = layer._vertices;
        var ctx = this._ctx;

        this._drawnLayers[layer._leaflet_id] = layer;

        //  TODO: Do we need to do a 'beginPath()' and possible 'closePath()' per ring?!
        ctx.beginPath();

        for (i = 0; i < vertices.length; i++) {
            points = vertices[i];
            x = y = 0;
            j = k = 0;
            while (j < points.length) {
                d = drawings[i][k++];
                switch (d) {
                    case 'M':
                        x = points[j].x;
                        y = points[j].y;
                        j += 1;
                        ctx.moveTo(x, y);
                        break;

                    case 'm':
                        x += points[j].x;
                        y += points[j].y;
                        j += 1;
                        ctx.moveTo(x, y);
                        break;

                    case 'L':
                        x = points[j].x;
                        y = points[j].y;
                        j += 1;
                        ctx.lineTo(x, y);
                        break;

                    case 'l':
                        x += points[j].x;
                        y += points[j].y;
                        j += 1;
                        ctx.lineTo(x, y);
                        break;

                    case 'C':
                        _x = points[j].x;
                        _y = points[j].y;
                        j += 1;
                        $x = points[j].x;
                        $y = points[j].y;
                        j += 1;
                        x = points[j].x;
                        y = points[j].y;
                        j += 1;
                        ctx.bezierCurveTo(_x, _y, $x, $y, x, y);
                        break;

                    case 'c':
                        _x = x + points[j].x;
                        _y = y + points[j].y;
                        j += 1;
                        $x = x + points[j].x;
                        $y = y + points[j].y;
                        j += 1;
                        x = x + points[j].x;
                        y = y + points[j].y;
                        j += 1;
                        ctx.bezierCurveTo(_x, _y, $x, $y, x, y);
                        break;

                    case 'Q':
                        _x = points[j].x;
                        _y = points[j].y;
                        j += 1;
                        x = points[j].x;
                        y = points[j].y;
                        j += 1;
                        ctx.quadraticCurveTo(_x, _y, x, y);
                        break;

                    case 'q':
                        _x = x + points[j].x;
                        _y = y + points[j].y;
                        j += 1;
                        x = x + points[j].x;
                        y = y + points[j].y;
                        j += 1;
                        ctx.quadraticCurveTo(_x, _y, x, y);
                        break;
                }
            }
            if (closed) {
                ctx.closePath();
            }
        }

        this._fillStroke(ctx, layer);
    }
});


DG.extend(L.SVG.prototype, {
    _updateComplexPath: function(layer, closed) {
        this._setPath(layer, L.SVG.complexPointsToPath(layer._vertices, layer._drawings, closed));
    }
});


DG.extend(L.SVG, {
    complexPointsToPath: function(vertices, drawings, closed) {
        var str = '';
        var svg = DG.Browser.svg;
        var i, j, k, n, d, points;

        for (i = 0; i < vertices.length; i++) {
            points = vertices[i];

            //  Speedup hot path by removing if/ternary condition checks but duplicating loops
            if (svg) {
                j = k = 0;
                while (j < points.length) {
                    d = drawings[i][k++];
                    switch (d) {
                        case 'C':
                        case 'c':   n = 3; break;
                        case 'Q':
                        case 'q':   n = 2; break;

                        default:    n = 1;  //  'M', 'm', 'L', 'l', ...
                    }
                    str += d;
                    while (n--) {
                        str += points[j].x.toFixed(4) + ',' + points[j].y.toFixed(4) + ' ';
                        j += 1;
                    }
                }
            } else {
                //  vml in IE8 can support only integer values in 'path', sorry about loss of precision
                j = k = 0;
                while (j < points.length) {
                    d = drawings[i][k++];
                    switch (d) {
                        case 'M':   d = 'm'; n = 1; break;
                        case 'm':   d = 't'; n = 1; break;
                        case 'L':   d = 'l'; n = 1; break;
                        case 'l':   d = 'r'; n = 1; break;
                        case 'C':   d = 'c'; n = 3; break;
                        case 'c':   d = 'v'; n = 3; break;
                        case 'Q':
                            //  VML spec has 'qb' command in 'v' attribute string but no 'relativeTo' compliment
                            //  So we'll emulate Cubic Bézier curve by applying Quadratic variant in both cases
                            //  TODO: Both control points will use the same value but this is not true solution
                            str += 'C' +
                                points[j].x.toFixed(0) + ',' + points[j].y.toFixed(0) + ' ' +
                                points[j].x.toFixed(0) + ',' + points[j].y.toFixed(0) + ' ' +
                                points[j + 1].x.toFixed(0) + ',' + points[j + 1].y.toFixed(0) + ' ';
                            j += 2;
                            d = '';
                            n = 0;
                            break;
                        case 'q':
                            str += 'c' +
                                points[j].x.toFixed(0) + ',' + points[j].y.toFixed(0) + ' ' +
                                points[j].x.toFixed(0) + ',' + points[j].y.toFixed(0) + ' ' +
                                points[j + 1].x.toFixed(0) + ',' + points[j + 1].y.toFixed(0) + ' ';
                            j += 2;
                            d = '';
                            n = 0;
                            break;

                        default:    n = 1;
                    }
                    str += d;
                    while (n--) {
                        str += points[j].x.toFixed(0) + ',' + points[j].y.toFixed(0) + ' ';
                        j += 1;
                    }
                }
            }

            str += closed ? (svg ? 'z' : 'x') : '';
        }

        // SVG complains about empty path strings
        return str || 'm0,0';
    }
});


================================================
FILE: src/DGEntrance/src/DGVertexTransform.js
================================================
/*
 * DG.VertexTransform is a classic 2D matrix transformation class
 *
 * Prototype methods can scale/rotate/translate vertices
 *
 * Static methods do the same but return simple array instances with attached
 * .clone() method which can reconstruct full DG.VertexTransform object
 */

DG.VertexTransform = DG.Class.extend({
    initialize: function(vertices) {
        this._vertices = vertices;

        this._scale = null;
        this._angle = null;
        this._trans = null;
        this._matrix = null;

        this.load();
    },

    load: function() {
        this.vertices = this._vertices.map(function(vertex) { return vertex.clone(); });
        this.vertices.clone = DG.VertexTransform.clone;

        return this;
    },

    save: function() {
        this._vertices = this.vertices.map(function(vertex) { return vertex.clone(); });

        return this;
    },

    setScale: function(scale) {
        this._scale = scale;
        return this;
    },

    getScale: function() {
        return this._scale;
    },

    setAngle: function(angle) {
        this._angle = angle;
        return this;
    },

    getAngle: function() {
        return this._angle;
    },

    setTranslation: function(trans) {
        this._trans = trans;
        return this;
    },

    getTranslation: function() {
        return this._trans;
    },

    setMatrix: function(matrix) {
        this._matrix = matrix;
        return this;
    },

    getMatrix: function() {
        return this._matrix;
    },

    scale: function(scale) {
        var v = this.vertices;
        var i = v.length;

        scale = scale || this._scale || 1;
        while (i--) {
            v[i].x *= scale;
            v[i].y *= scale;
        }

        return this;
    },

    unScale: function(scale) {
        scale = scale || this._scale || 1;      //  Also safeguard against zero scale
        return this.scale(1 / scale);
    },

    rotate: function(angle) {
        var cos = angle ? angle.cos : (this._angle ? this._angle.cos : 1);
        var sin = angle ? angle.sin : (this._angle ? this._angle.sin : 0);
        var v = this.vertices;
        var i = v.length;
        var x, y;

        while (i--) {
            x = v[i].x;
            y = v[i].y;
            v[i].x = x * cos - y * sin;
            v[i].y = x * sin + y * cos;
        }

        return this;
    },

    unRotate: function(angle) {
        var cos = angle ? angle.cos : (this._angle ? this._angle.cos : 1);
        var sin = angle ? angle.sin : (this._angle ? this._angle.sin : 0);

        return this.rotate({cos: cos, sin: -sin});
    },

    translate: function(trans) {
        var dx = trans ? trans.x : (this._trans ? this._trans.x : 0);
        var dy = trans ? trans.y : (this._trans ? this._trans.y : 0);
        var v = this.vertices;
        var i = v.length;

        while (i--) {
            v[i].x += dx;
            v[i].y += dy;
        }

        return this;
    },

    unTranslate: function(trans) {
        var dx = trans ? trans.x : (this._trans ? this._trans.x : 0);
        var dy = trans ? trans.y : (this._trans ? this._trans.y : 0);

        return this.translate({x: -dx, y: -dy});
    },

    transform: function(matrix) {
        var a, b, c, d, dx, dy;
        var v = this.vertices;
        var i = v.length;
        var x, y;

        if (matrix) {
            a = matrix[0]; b = matrix[1]; dx = matrix[2];
            c = matrix[3]; d = matrix[4]; dy = matrix[5];
        } else if (this._matrix) {
            a = this._matrix[0]; b = this._matrix[1]; dx = this._matrix[2];
            c = this._matrix[3]; d = this._matrix[4]; dy = this._matrix[5];
        } else {
            a = 1; b = 0; dx = 0;
            c = 0; d = 1; dy = 0;
        }

        while (i--) {
            x = v[i].x;
            y = v[i].y;
            v[i].x = x * a + y * b + dx;
            v[i].y = x * c + y * d + dy;
        }

        return this;
    },

    statics: {
        scale: function(vt, scale) {
            var v = vt.vertices;
            var result = [];
            var x, y;

            scale = scale || 1;
            for (var i = 0; i < v.length; i++) {
                x = v[i].x * scale;
                y = v[i].y * scale;
                result.push(new DG.Point(x, y));
            }
            result.clone = DG.VertexTransform.clone;

            return result;
        },

        unScale: function(vt, scale) {
            scale = scale || 1;         //  Also safeguard against zero scale
            return DG.VertexTransform.scale(vt, 1 / scale);
        },

        rotate: function(vt, angle) {
            var cos = angle ? angle.cos : 1;
            var sin = angle ? angle.sin : 0;
            var v = vt.vertices;
            var x, y, rx, ry;
            var result = [];

            for (var i = 0; i < v.length; i++) {
                rx = v[i].x;
                ry = v[i].y;
                x = rx * cos - ry * sin;
                y = rx * sin + ry * cos;
                result.push(new DG.Point(x, y));
            }
            result.clone = DG.VertexTransform.clone;

            return result;
        },

        unRotate: function(vt, angle) {
            var cos = angle ? angle.cos : 1;
            var sin = angle ? angle.sin : 0;

            return DG.VertexTransform.rotate(vt, {cos: cos, sin: -sin});
        },

        translate: function(vt, trans) {
            var dx = trans ? trans.x : 0;
            var dy = trans ? trans.y : 0;
            var v = vt.vertices;
            var result = [];
            var x, y;

            for (var i = 0; i < v.length; i++) {
                x = v[i].x + dx;
                y = v[i].y + dy;
                result.push(new DG.Point(x, y));
            }
            result.clone = DG.VertexTransform.clone;

            return result;
        },

        unTranslate: function(vt, trans) {
            var dx = trans ? trans.x : 0;
            var dy = trans ? trans.y : 0;

            return DG.VertexTransform.translate(vt, {x: -dx, y: -dy});
        },

        clone: function() {
            //  'this' is an array
            return new DG.VertexTransform(this).save();
        },

        getLength: function(vec1, vec2) {
            var dx, dy;

            if (typeof vec1 === 'number') {
                //  'vec1' and 'vec2' are absolute coordinates of vector
                return Math.sqrt(vec1 * vec1 + vec2 * vec2);
            } else {
                //  'vec1' and 'vec2' are vector objects
                dx = vec2.x - vec1.x;
                dy = vec2.y - vec1.y;
                return Math.sqrt(dx * dx + dy * dy);
            }
        },

        getScaled: function(vec1, vec2, scale) {
            var dx, dy;

            if (typeof vec1 === 'number') {
                //  'vec1' and 'vec2' are absolute coordinates of vector
                return new DG.Point(vec1 * scale, vec2 * scale);
            } else {
                //  'vec1' and 'vec2' are vector objects
                dx = (vec2.x - vec1.x) * scale;
                dy = (vec2.y - vec1.y) * scale;
                return new DG.Point(vec1.x + dx, vec1.y + dy);
            }
        },

        getAngle: function(vec1, vec2, origin) {
            var l, sp, x1, y1, x2, y2;

            if (typeof vec1 === 'number') {
                //  'vec1' and 'vec2' are absolute coordinates of vector
                l = Math.sqrt(vec1 * vec1 + vec2 * vec2);
                if (l > 0) {
                    return {cos: vec1 / l, sin: vec2 / l};
                } else {
                    return {cos: 1, sin: 0};
                }
            } else {
                //  'vec1' and 'vec2' are vector objects
                x1 = vec1.x; y1 = vec1.y;
                x2 = vec2.x; y2 = vec2.y;
                if (origin) {
                    x1 -= origin.x; y1 -= origin.y;
                    x2 -= origin.x; y2 -= origin.y;
                }
                sp = Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2);
                return {
                    cos: (x1 * x2 + y1 * y2) / sp,
                    sin: (x1 * y2 - x2 * y1) / sp
                };
            }
        },

        getAnglesSum: function(angle1, angle2) {
            return {
                cos: angle1.cos * angle2.cos - angle1.sin * angle2.sin,
                sin: angle1.sin * angle2.cos + angle1.cos * angle2.sin
            };
        },

        getAnglesDif: function(angle1, angle2) {
            return {
                cos: angle1.cos * angle2.cos + angle1.sin * angle2.sin,
                sin: angle1.sin * angle2.cos - angle1.cos * angle2.sin
            };
        }
    }
});


================================================
FILE: src/DGEntrance/test/DGArrowShapeSpec.js
================================================
describe('DG.Entrance.Arrow.SHAPE', function () {
    var dgArrowShape = DG.Entrance.Arrow.SHAPE;

    after(function () {
        dgArrowShape = null;
    });

    it('should be an object', function () {
        expect(dgArrowShape).to.be.an('object');
    });

    it('should contain paired \'vertices\' and \'drawings\' objects', function () {
        var v = Object.keys(dgArrowShape.vertices);
        var d = Object.keys(dgArrowShape.drawings);

        expect(v.length).to.be.equal(d.length);
        expect(v).to.be.eql(d);
    });

    it('should contain paired \'vertices\' and \'drawings\' elements', function () {
        var vertices = dgArrowShape.vertices;
        var drawings = dgArrowShape.drawings;
        var k = Object.keys(drawings);

        for (var i = 0; i < k.length; i++) {
            var d = drawings[k[i]];
            for (var len = 0, j = 0; j < d.length; j++) {
                switch(d[j]) {
                    case 'C':
                    case 'c': len += 3; break;
                    case 'Q':
                    case 'q': len += 2; break;

                    default:  len += 1;
                }
            }
            expect(len).to.be.equal(vertices[k[i]].length);
        }
    });

    it('should contain instances of \'DG.Point\' objects in \'vertices\' arrays', function () {
        var vertices = dgArrowShape.vertices;
        var k = Object.keys(vertices);

        for (var i = 0; i < k.length; i++) {
            var v = vertices[k[i]];
            for (var j = 0; j < v.length; j++) {
                expect(v[j]).to.be.an(DG.Point);
            }
        }
    });
});


================================================
FILE: src/DGEntrance/test/DGBezierSpec.js
================================================
describe('DG.Bezier', function () {
    var s = DG.point(1, 0), e = DG.point(7, 0),
        cp1 = DG.point(3, 1), cp2 = DG.point(5, -1);

    var bc;

    beforeEach(function () {
        bc = new DG.Bezier([s, cp1, cp2, e]);
    });

    after(function () {
        bc = s = e = cp1 = cp2 = null;
    });

    describe('#getPoint', function () {
        it('should return correct curve\'s point coordinates at specific (t) value', function () {
            expect(bc.getPoint(0.50)).to.be.eql({x: 4, y: 0});
            expect(bc.getPoint(0.25)).to.be.eql({x: 2.5, y: 0.28125});
            expect(bc.getPoint(0.75)).to.be.eql({x: 5.5, y: -0.28125});
        });
    });

    describe('#getLength', function () {
        it('should return correct (approximated) curve\'s length', function () {
            expect(bc.getLength()).to.be.within(6.1462605, 6.1462615);
        });
    });

    describe('#getCurveBefore', function () {
        it('should return new curve as a (beginning) part of original', function () {
            expect(bc.getCurveBefore(0.25).points)
                .to.be.eql([{x: 1, y: 0}, {x: 1.5, y: 0.25}, {x: 2, y: 0.3125}, {x: 2.5, y: 0.28125}]);
        });
    });

    describe('#getCurveAfter', function () {
        it('should return new curve as a (ending) part of original', function () {
            expect(bc.getCurveAfter(0.25).points)
                .to.be.eql([{x: 2.5, y: 0.28125}, {x: 4, y: 0.1875}, {x: 5.5, y: -0.75}, {x: 7, y: 0}]);
        });
    });
});


describe('DG.TimeBezier', function () {
    var cp1 = DG.point(0.42, 0.0);
    var cp2 = DG.point(0.58, 1.0);

    it('should return correct distance (Y) by time (X) value', function () {
        expect(new DG.TimeBezier(cp1, cp2).getYbyX(0.37)).to.be.within(0.2851635, 0.2851640);
    });
});


describe('DG.ArcBezier', function () {
    var s = DG.point(1, 0), e = DG.point(7, 0),
        cp1 = DG.point(3, 1), cp2 = DG.point(5, -1);

    var bc = new DG.ArcBezier([s, cp1, cp2, e]);

    after(function () {
        bc = null;
    });

    it('should return correct (t) value by curve\'s segment length', function () {
        expect(bc.getTbyL(3)).to.be.within(0.485, 0.490);
    });

    it('should return correct (t) value by curve\'s segment length', function () {
        expect(bc.getLength()).to.be.within(6.1461, 6.1463);
    });
});


================================================
FILE: src/DGEntrance/test/DGMetricSpec.js
================================================
describe('DG.Metric', function () {
    var dgMetric = DG.Metric;

    it('should be a function object', function () {
        expect(dgMetric).to.be.a('function');
    });

    describe('DG.Metric.Segments', function () {
        var dgMetricSegments;

        beforeEach(function () {
            dgMetricSegments = new dgMetric.Segments();
        });
        
        after(function () {
            dgMetricSegments = null;
        });

        describe('#push', function () {
            it('should return \'DG.Metric.Segments\' instance', function () {
                expect(dgMetricSegments.push(0)).to.be.a(DG.Metric.Segments);
            });

            it('should update .length counter', function () {
                expect(dgMetricSegments.push(0).push(1).push(2).length).to.be.equal(3);
            });
        });

        describe('#getLength', function () {
            it('should return correct total segments length in case of [0]', function () {
                expect(dgMetricSegments.push(0).getLength()).to.be.equal(0);
            });

            it('should return correct total segments length in case of [0, 1, 2]', function () {
                expect(dgMetricSegments.push(2).push(1).push(0).getLength()).to.be.equal(3);
            });
        });

        describe('#getReverse', function () {
            it('should return new instance of \'DG.Metric.Segments\'', function () {
                var segments = dgMetricSegments.getReverse();
                expect(segments).to.be.a(DG.Metric.Segments);
                expect(segments).not.equal(dgMetricSegments);
            });

            it('should return correct total segments length', function () {
                expect(dgMetricSegments.push(2).push(3).push(5).getReverse().getLength()).to.be.equal(10);
            });

            it('should map to correct segment lengths', function () {
                expect(dgMetricSegments.push(2).push(3).push(5).getReverse())
                    .to.be.eql({'0': 5, '1': 8, '2': 10, length: 3});
            });
        });

        describe('#getIndex', function () {
            it('should return correct index value in case of []', function () {
                expect(dgMetricSegments.getIndex(5)).to.be.equal(-1);
            });

            it('should return correct index value in case of [1, 2, 3]', function () {
                expect(dgMetricSegments.push(1).push(2).push(3).getIndex(2)).to.be.equal(1);
            });

            it('should return correct index value in case of [3, 2, 1]', function () {
                expect(dgMetricSegments.push(3).push(2).push(1).getIndex(2)).to.be.equal(0);
            });
        });

        describe('#getSegRatio', function () {
            it('should return correct intra-segment ratio value in case of [1, 2, 3]', function () {
                expect(dgMetricSegments.push(1).push(2).push(3).getSegRatio(4.5)).to.be.equal((4.5 - 3) / (6 - 3));
            });

            it('should return correct intra-segment ratio value in case of [3, 2, 1]', function () {
                expect(dgMetricSegments.push(3).push(2).push(1).getSegRatio(4.5)).to.be.equal((4.5 - 3) / (5 - 3));
            });
        });

        describe('#getSegLength', function () {
            it('should return correct segment length in case of [1, 2, 3]', function () {
                expect(dgMetricSegments.push(1).push(2).push(3).getSegLength(5)).to.be.equal(2);
            });

            it('should return correct segment length in case of [3, 2, 1]', function () {
                expect(dgMetricSegments.push(3).push(2).push(1).getSegLength(5)).to.be.equal(0);
            });
        });
    });
});


================================================
FILE: src/DGEntrance/test/DGTransformSpec.js
================================================
describe('DG.VertexTransform', function () {
    var a030 = Math.PI / 6,
        a045 = Math.PI / 4,
        a120 = Math.PI * 2 / 3,
        a210 = Math.PI * 7 / 6,

        p1 = DG.point(0, 0),
        p2 = DG.point(1, 0),
        p3 = DG.point(Math.cos(a030), Math.sin(a030)),
        p4 = DG.point(-Math.cos(a030), -Math.sin(a030)),
        p5 = DG.point(3, -4),
        p6 = DG.point(12.3, 45.6),

        DGVT = DG.VertexTransform, vt,
        EPSILON = 0.000000000000001;

    beforeEach(function () {
        vt = new DG.VertexTransform([p1, p2, p3, p4, p5, p6]);
    });

    after(function () {
        vt = p1 = p2 = p3 = p4 = p5 = p6 = null;
    });

    it('should contain chaining methods', function () {
        expect(vt.load().save().setScale(1).setAngle({cos: 1, sin: 0}).setTranslation({x: 0, y: 0}).setMatrix([1, 0, 0, 0, 1, 0])
            .scale().unScale().rotate().unRotate().translate().unTranslate().transform().vertices).to.be.an('array');
    });

    describe('statics', function () {
        it('should return array objects with working \'.clone()\' method', function () {
            expect(DGVT.scale(vt).clone().vertices).to.be.eql(vt.vertices);
            expect(DGVT.unScale(vt).clone().vertices).to.be.eql(vt.vertices);
            expect(DGVT.rotate(vt).clone().vertices).to.be.eql(vt.vertices);
            expect(DGVT.unRotate(vt).clone().vertices).to.be.eql(vt.vertices);
            expect(DGVT.translate(vt).clone().vertices).to.be.eql(vt.vertices);
            expect(DGVT.unTranslate(vt).clone().vertices).to.be.eql(vt.vertices);
        });

        describe('cloned objects', function () {
            it('should be distinct from original objects', function () {
                expect(DGVT.scale(vt).clone().vertices[0]).not.to.be(vt._vertices[0]);
                expect(DGVT.unScale(vt).clone().vertices[0]).not.to.be(vt._vertices[0]);
                expect(DGVT.rotate(vt).clone().vertices[0]).not.to.be(vt._vertices[0]);
                expect(DGVT.unRotate(vt).clone().vertices[0]).not.to.be(vt._vertices[0]);
                expect(DGVT.translate(vt).clone().vertices[0]).not.to.be(vt._vertices[0]);
                expect(DGVT.unTranslate(vt).clone().vertices[0]).not.to.be(vt._vertices[0]);
            });
        });
    });

    describe('#getLength', function () {
        it('should return correct length value in (vertex) case', function () {
            var pc = p5.clone();
            expect(DGVT.getLength(pc.x, pc.y)).to.be.equal(5);
        });

        it('should return correct length value in (vertex, vertex) case', function () {
            expect(DGVT.getLength(DG.point(10, -5), DG.point(13, -1))).to.be.equal(5);
        });
    });

    describe('#getScaled', function () {
        it('should return correct scaled vector in (vertex) case', function () {
            expect(DGVT.getScaled(p5.x, p5.y, 2)).to.be.eql({x: 6, y: -8});
        });

        it('should return correct scaled vector in (vertex, vertex) case', function () {
            expect(DGVT.getScaled(DG.point(10, -5), DG.point(13, -1), 0.5)).to.be.eql({x: 11.5, y: -3});
        });
    });

    describe('#getAngle', function () {
        it('should return correct angle in (vertex) case', function () {
            expect(DGVT.getAngle(p3.x, p3.y)).to.be.eql({cos: p3.x, sin: p3.y});
            expect(DGVT.getAngle(p5.x, p5.y)).to.be.eql({cos: 0.6, sin: -0.8});
        });

        it('should return correct angle in (vertex, vertex) case', function () {
            expect(DGVT.getAngle(p3.clone(), p2.clone(), p1.clone())).to.be.eql({cos: p3.x, sin: -p3.y});

            var angle = 4.048560303417995,
                cos = Math.cos(angle),
                sin = Math.sin(angle);

            angle = DGVT.getAngle(p6.clone(), p5.clone(), p1.clone());
            expect(Math.abs(angle.cos - cos) < EPSILON).to.be.ok();
            expect(Math.abs(angle.sin - sin) < EPSILON).to.be.ok();
        });
    });

    describe('#getAngles(Sum/Dif)', function () {
        it('should return correct angle', function () {
            var cos045 = Math.cos(a045),
                sin045 = Math.sin(a045),
                cos210 = Math.cos(a210),
                sin210 = Math.sin(a210),
                angle, cos, sin;

            angle = a045 + a210;
            cos = Math.cos(angle);
            sin = Math.sin(angle);
            angle = DGVT.getAnglesSum({cos: cos045, sin: sin045}, {cos: cos210, sin: sin210});
            expect(Math.abs(angle.cos - cos) < EPSILON).to.be.ok();
            expect(Math.abs(angle.sin - sin) < EPSILON).to.be.ok();

            angle = a045 - a210;
            cos = Math.cos(angle);
            sin = Math.sin(angle);
            angle = DGVT.getAnglesDif({cos: cos045, sin: sin045}, {cos: cos210, sin: sin210});
            expect(Math.abs(angle.cos - cos) < EPSILON).to.be.ok();
            expect(Math.abs(angle.sin - sin) < EPSILON).to.be.ok();
        });
    });


    describe('prototype', function () {
        describe('#scale', function () {
            it('should return correctly scaled vertices', function () {
                expect(vt.scale(2).save()._vertices).to.be
                    .eql([p1, p2, p3, p4, p5, p6].map(function (p) {
                        return {x: p.x * 2, y: p.y * 2};
                    }));

                expect(vt.setScale(0.25).scale().save()._vertices).to.be
                    .eql([p1, p2, p3, p4, p5, p6].map(function (p) {
                        return {x: p.x / 2, y: p.y / 2};
                    }));

                expect(vt.unScale(0.5).save()._vertices).to.be.eql([p1, p2, p3, p4, p5, p6]);
            });
        });

        describe('#rotate', function () {
            it('should return correctly rotated vertices', function () {
                var cos = Math.cos(a120), sin = Math.sin(a120);

                expect(vt.rotate({cos: cos, sin: sin}).save()._vertices).to.be
                    .eql([p1, p2, p3, p4, p5, p6].map(function (p) {
                        return {x: p.x * cos - p.y * sin, y: p.x * sin + p.y * cos};
                    }));

                expect(vt.setAngle({cos: 0, sin: 1}).rotate().save()._vertices).to.be
                    .eql([p1, p2, p3, p4, p5, p6].map(function (p) {
                        return {x: -(p.x * sin + p.y * cos), y: p.x * cos - p.y * sin};
                    }));

                cos = Math.cos(a210); sin = Math.sin(a210);
                vt.unRotate({cos: cos, sin: sin});
                [p1, p2, p3, p4, p5, p6].forEach(function (p, i, a) {
                    expect(Math.abs(a[i].x - vt.vertices[i].x) < EPSILON * 10).to.be.ok();
                    expect(Math.abs(a[i].y - vt.vertices[i].y) < EPSILON * 10).to.be.ok();
                });
            });
        });

        describe('#translate', function () {
            it('should return correctly translated vertices', function () {
                expect(vt.translate(p5.clone()).save()._vertices).to.be
                    .eql([p1, p2, p3, p4, p5, p6].map(function (p) {
                        return {x: p.x + p5.x, y: p.y + p5.y};
                    }));

                expect(vt.setTranslation(DG.point(9.3, 49.6)).translate().save()._vertices).to.be
                    .eql([p1, p2, p3, p4, p5, p6].map(function (p) {
                        return {x: p.x + p6.x, y: p.y + p6.y};
                    }));

                vt.unTranslate(p6.clone());
                [p1, p2, p3, p4, p5, p6].forEach(function (p, i, a) {
                    expect(Math.abs(a[i].x - vt.vertices[i].x) < EPSILON).to.be.ok();
                    expect(Math.abs(a[i].y - vt.vertices[i].y) < EPSILON).to.be.ok();
                });
            });
        });
    });
});


================================================
FILE: src/DGEntrance/test/EntranceSpec.js
================================================
describe('DG.Entrance', function () {
    var map,
        spy,
        entrance,
        mapContainer = document.createElement('div'),
        ua = navigator.userAgent.toLowerCase(),
        ff = ua.indexOf('firefox') > -1;

    after(function() {
        entrance.remove();
        map && map.remove();
        map = spy = entrance = mapContainer = ua = ff = null;
    });

    beforeEach(function () {
        map = new DG.Map(mapContainer, {
            center: new DG.LatLng(69.349552990994837, 87.75222519148015),
            zoom: 17,
            key: window.__karma__.config.secretKey,
        });
        entrance = new DG.Entrance({
            'is_primary': false,
            'name': 'ЗАГС',
            'points': ['POINT(87.75222519148015 69.349552990994837)'],
            'vectors': ['LINESTRING(87.752433542237128 69.349501774294012,87.75222519148015 69.349552990994837)']
        });
    });

    afterEach(function () {
        entrance.removeFrom(map);
        map && map.remove();
        map = null;
    });

    // since ff/mocha/phantom has some strange bug with svg beginElement()
    if (!ff) {
        describe('#addTo', function () {
            it('should return \'DG.Entrance\' instance', function () {
                expect(entrance.addTo(map)).to.be.a(DG.Entrance);
            });

            it('should fire \'entranceshow\' event', function () {
                spy = sinon.spy();
                map.on('entranceshow', spy);
                entrance.addTo(map);
                expect(spy.called).to.be.ok();
            });

            it('should not fire \'entranceshow\' event if already shown', function () {
                entrance.addTo(map);
                spy = sinon.spy();
                map.on('entranceshow', spy);
                entrance.addTo(map);
                expect(spy.called).not.to.be.ok();
            });

            it('should adjust map center and show entrance in viewport', function () {
                map.setView([54.980206086231, 82.898068362003], 17); // Novosibirsk
                entrance.addTo(map);
                entrance.fitBounds();
                expect(map.getCenter()).to.eql(entrance.getBounds().getCenter()); // Kayerkan
            });

            it('should add layers on map and visible container', function() {
                var layers = entrance._layers;

                entrance.addTo(map);

                Object.keys(layers).forEach(function(el) {
                    expect(map.hasLayer(layers[el])).to.be.ok();
                    expect(layers[el]._visibility.isShown).to.be(true);
                });
            });
        });
    }
    describe('#removeFrom', function () {

        it('should return \'DG.Entrance\' instance', function () {
            expect(entrance.removeFrom(map)).to.be.a(DG.Entrance);
        });
        if (!ff) {
            it('should fire \'entrancehide\' event', function () {
                entrance.addTo(map);
                spy = sinon.spy();
                map.on('entrancehide', spy);
                entrance.removeFrom(map);
                expect(spy.called).to.be.ok();
            });
        }
        it('should not fire \'entrancehide\' event if already hidden (hidden by default)', function () {
            spy = sinon.spy();
            map.on('entrancehide', spy);
            entrance.removeFrom(map);
            expect(spy.called).not.to.be.ok();
        });

        it('should layers not on map and not visible container', function() {
            var layers = entrance._layers;

            Object.keys(layers).forEach(function(el) {
                expect(map.hasLayer(layers[el])).not.be.ok();
                expect(layers[el]._visibility.isShown).not.be(true);
            });
        });

    });

    describe('#isShown', function () {

        it('should return \'false\' by default', function () {
            expect(entrance.isShown()).not.to.be.ok();
        });
        if (!ff) {
            it('should return \'true\' after show and \'false\' after hide', function () {
                entrance.addTo(map);
                expect(entrance.isShown()).to.be.ok();
                entrance.removeFrom(map);
                expect(entrance.isShown()).not.to.be.ok();
            });
        }
    });

    describe('#getBounds', function () {

        it('should return bounds of all arrows of the entrance', function () {
            var entranceBounds = new DG.LatLngBounds(
                [69.349552990994837, 87.75222519148015],
                [69.349501774294012, 87.752433542237128]
            );
            expect(entrance.getBounds()).to.eql(entranceBounds);
        });
    });

});


================================================
FILE: src/DGFullScreen/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset='utf-8'>
  <title>DGFullScreen Demo</title>
  <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>

</head>
<body>

  <div id="map" style="width: 100%; height: 600px; border: 1px solid #ccc;"></div>

  <script type="text/javascript">

  DG.then(function () {

    map = new DG.Map('map', {
        center: new DG.LatLng(54.980206086231, 82.898068362003),
        zoom:12,
        key: DG.config.key || 'Your API access key'
        // возможно отключить кнопку фулскрина передав опцию
        //fullscreenControl: false
    });

    // изменить дефолтное положение контрола
    map.fullscreenControl.setPosition('bottomleft');

  });
  </script>

</body>
</html>


================================================
FILE: src/DGFullScreen/lang/ar.js
================================================
DG.Control.Fullscreen.Dictionary.ar = {
    title_max : '',
    title_min : ''
};


================================================
FILE: src/DGFullScreen/lang/cs.js
================================================
DG.Control.Fullscreen.Dictionary.cs = {
    title_max : 'Rozbalit',
    title_min : 'Obnovit'
};


================================================
FILE: src/DGFullScreen/lang/en.js
================================================
DG.Control.Fullscreen.Dictionary.en = {
    title_max : 'Expand',
    title_min : 'Restore'
};


================================================
FILE: src/DGFullScreen/lang/es.js
================================================
DG.Control.Fullscreen.Dictionary.es = {
    title_max : 'Maximizar',
    title_min : 'Restaurar'
};


================================================
FILE: src/DGFullScreen/lang/it.js
================================================
DG.Control.Fullscreen.Dictionary.it = {
    title_max : 'Espandi',
    title_min : 'Ripristina'
};


================================================
FILE: src/DGFullScreen/lang/ru.js
================================================
DG.Control.Fullscreen.Dictionary.ru = {
    title_max : 'Развернуть',
    title_min : 'Восстановить'
};


================================================
FILE: src/DGFullScreen/skin/basic/less/dg-control-round.less
================================================
.dg-control-round__icon_name_fullscreen {
    &:after {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        margin: auto;
        content: '';
    }

    .dg-control-round__icon_state_active&:after,
    .no-touch .dg-control-round__icon_state_active&:hover:after,
    .dg-control-round__icon_state_active&:active:after {
        .notRepeatableBg('DGRoundControl__fullscreenIconEnabled');
    }
}


================================================
FILE: src/DGFullScreen/skin/basic/less/dg-fullscreen.ie.less
================================================
.dg-fullscreen {
    zoom: 1;
    .opacity(.8);
}

.dg-fullscreen:hover {
    .opacity(1);
}


================================================
FILE: src/DGFullScreen/skin/dark/less/dg-control-round.less
================================================
.dg-control-round__icon_name_fullscreen {
    &:after {
        .notRepeatableBgWithSizes('DGRoundControl__fullscreenIcon_dark');
    }

    .no-touch &:hover:after,
    &:active:after {
        .notRepeatableBg('DGRoundControl__fullscreenIconHover_dark');
    }
}


================================================
FILE: src/DGFullScreen/skin/light/less/dg-control-round.less
================================================
.dg-control-round__icon_name_fullscreen {
    &:after {
        .notRepeatableBgWithSizes('DGRoundControl__fullscreenIcon_light');
    }

    .no-touch &:hover:after,
    &:active:after {
        .notRepeatableBg('DGRoundControl__fullscreenIconHover_light');
    }
}


================================================
FILE: src/DGFullScreen/src/DGFullScreen.js
================================================
DG.Control.Fullscreen = DG.RoundControl.extend({

    statics: {
        Dictionary: {}
    },

    options: {
        position: 'topright',
        iconClass: 'fullscreen'
    },

    initialize: function(options) {
        DG.Util.setOptions(this, options);
        this._isFullscreen = false;
        this.on('click', this._toggleFullscreen);
    },

    _toggleFullscreen: function() {
        if (!this._isFullscreen) {
            this._toggle(true, 'request', 'on', 'requestfullscreen');
        } else {
            this._toggle(false, 'exit', 'on', 'cancelfullscreen');
        }

        this._renderTranslation();
        this._map.invalidateSize();
    },

    _renderTranslation: function() {
        this._link.title = this.t(this._isFullscreen ? 'title_min' : 'title_max');
    },

    _toggle: function(isEnabled, method, list, event) {
        var container = this._map._container;

        this._isFullscreen = isEnabled;
        this.setState(isEnabled ? 'active' : '');

        DG.screenfull[method](container);
        DG.DomEvent[list](document, DG.screenfull.api.fullscreenchange, this._onFullScreenStateChange, this);
        this._map.fire(event);
    },

    _onFullScreenStateChange: function() {
        if (!DG.screenfull.isFullscreen()) {
            this._toggle(false, 'exit', 'on', 'cancelfullscreen');
        }
    }
});

DG.control.fullscreen = function(options) {
    return new DG.Control.Fullscreen(options);
};

DG.Map.mergeOptions({
    fullscreenControl: true
});

DG.Map.addInitHook(function() {
    if (this.options.fullscreenControl) {
        this.fullscreenControl = DG.control.fullscreen(this.options.fullscreenControl);

        if (DG.screenfull.isAvailable()) {
            this.addControl(this.fullscreenControl);
        }
    }
});


================================================
FILE: src/DGFullScreen/src/DGScreenfull.js
================================================
// Inspired by Sindre Sorhus screenfull
DG.Screenfull = DG.Class.extend({
    _apiMap: [
        [
            'requestFullscreen',
            'exitFullscreen',
            'fullscreenElement',
            'fullscreenEnabled',
            'fullscreenchange',
            'fullscreenerror'
        ],
        [
            'webkitRequestFullscreen',
            'webkitExitFullscreen',
            'webkitFullscreenElement',
            'webkitFullscreenEnabled',
            'webkitfullscreenchange',
            'webkitfullscreenerror'

        ],
        [
            'mozRequestFullScreen',
            'mozCancelFullScreen',
            'mozFullScreenElement',
            'mozFullScreenEnabled',
            'mozfullscreenchange',
            'mozfullscreenerror'
        ],
        [
            'msRequestFullscreen',
            'msExitFullscreen',
            'msFullscreenElement',
            'msFullscreenEnabled',
            'MSFullscreenChange',
            'MSFullscreenError'
        ]
    ],

    initialize: function() {
        this.api = this._api();
    },

    request: function(elem) {
        var request = this.api.requestFullscreen;

        elem = elem || document.documentElement;
        elem[request](Element.ALLOW_KEYBOARD_INPUT);
    },

    exit: function() {
        document[this.api.exitFullscreen]();
    },

    isFullscreen: function() {
        return !!document[this.api.fullscreenElement];
    },

    isAvailable: function() {
        return Boolean(this.api);
    },

    _api: function() {
        var api = {},
            apiMap = this._apiMap;

        apiMap.forEach(function(val) {
            if (val && val[1] in document) {
                val.forEach(function(method, i) {
                    api[apiMap[0][i]] = method;
                });
            }
        });

        return api.requestFullscreen ? api : false;
    }
});

DG.screenfull = new DG.Screenfull();


================================================
FILE: src/DGFullScreen/src/LegacyFullScreen.js
================================================
if (!DG.screenfull.api ||
    //fallback since srange android ff bug with fullscreen mode
    (DG.Browser.android && DG.Browser.gecko) ||
    //fallback for safari5.1 because of error on fullscreen exit
    DG.Browser.safari51) {

    DG.Screenfull.include({
        _fullscreenClass: 'DGFullScreen_legacy-mode',
        _fullscreenBodyClass: this._fullscreenClass + '-body',
        _api: function() {
            return {fullscreenchange: 'keyup'};
        },

        _mapParams: [
            'zIndex', 'position', 'left', 'top', 'border', 'marginTop', 'marginRight',
            'marginBottom', 'marginLeft', 'paddingTop', 'paddingRight', 'paddingBottom',
            'paddingLeft', 'previousSibling', 'width', 'height'
        ],

        _documentParams: [
            'marginTop', 'marginRight', 'marginBottom', 'marginLeft', 'paddingTop',
            'paddingRight', 'paddingBottom', 'paddingLeft', 'overflow', 'scrollTop'
        ],
        _initialDocumentParams: {},
        _initialMapParams: {},
        _initialDocumentElementParams: {},

        exit: function(container) { // (HTMLDivElement)

            DG.DomUtil.removeClass(container, this._fullscreenClass);
            DG.DomUtil.removeClass(document.body, this._fullscreenBodyClass);

            // restore map container params
            this._mapParams.forEach(function(cssRule) {
                container.style[cssRule] = this._initialMapParams[cssRule];
            }, this);

            // restore map container params
            this._documentParams.forEach(function(cssRule) {
                document.body.style[cssRule] = this._initialDocumentParams[cssRule];
            }, this);

            // restore document.documentElement params
            document.documentElement.scrollTop = this._initialDocumentElementParams.scrollTop;
        },

        request: function(container) { // (HTMLDivElement)
            this._storePosition(container);
            // set full map mode style
            DG.DomUtil.addClass(container, this._fullscreenClass);
            DG.DomUtil.addClass(document.body, this._fullscreenBodyClass);

            // reset document.documentElement params
            document.documentElement.scrollTop = '0px';
        },

        _storePosition: function(container) { // (HTMLDivElement)

            // store initial map container params
            this._mapParams.forEach(function(cssRule) {
                this._initialMapParams[cssRule] = container.style[cssRule];
            }, this);

            // store initial document.body params
            this._documentParams.forEach(function(cssRule) {
                this._initialDocumentParams[cssRule] = document.body.style[cssRule];
            }, this);

            // store initial document.documentElement params
            this._initialDocumentElementParams.scrollTop = document.documentElement.scrollTop;
        },

        _onFullScreenStateChange: function(e) { // (Object)
            if (!e) {
                e = window.event;
            }
            if (e.keyCode === 27) {
                this._exitFullScreen();
            }
        }
    });

    DG.screenfull = new DG.Screenfull();
}


================================================
FILE: src/DGFullScreen/test/DGFullScreenSpec.js
================================================
/*global describe:false, it:false, expect:false, sinon:false */
describe.skip('DG.FullScreen', function () {
    var mapContainer, map, classControl, container, spy;

    before(function() {
        mapContainer = document.createElement('div');

        document.body.appendChild(mapContainer);

        map = new DG.Map(mapContainer, {
            center: [54.98117239821992, 82.88922250270844],
            key: window.__karma__.config.secretKey,
            'zoom': 17,
            'geoclicker': true,
            'zoomAnimation': false
        });

        classControl = 'dg-control-round__icon_name_fullscreen';
    });

    after(function() {
        map.remove();
        document.body.removeChild(mapContainer);
        mapContainer = map = classControl = container = spy = null;
    });

    describe('check init', function() {
        it('should be one container on map', function() {
            container = mapContainer.getElementsByClassName(classControl);
            expect(container.length).to.be(1);
            container = container[0];
        });

        it('should be DG.control.fullscreen', function() {
            expect(DG.control.fullscreen).to.be.ok();
        });
    });

    describe('enable fullscreen', function() {
        before(function() {
            spy = sinon.spy();
            map.on('requestfullscreen', spy);

            happen.click(container);
        });

        after(function() {
            map.off('requestfullscreen', spy);
            spy = null;
        });

        it('should fire request event', function() {
            expect(spy.calledOnce).to.be.ok();
        });

        // phantom hasn't fullscreen
        if (DG.screenfull.api['fullscreenElement']) {
            it('should enable fullscreen', function () {
                expect(document[DG.screenfull.api['fullscreenElement']]).to.be(null);
            });
        }

        it('should container has active class', function() {
            expect(container.className).to.contain('active');
        });
    });

    describe('enable fullscreen', function() {
        before(function() {
            spy = sinon.spy();
            map.on('cancelfullscreen', spy);

            happen.click(container);
        });

        after(function() {
            map.off('cancelfullscreen', spy);
            spy = null;
        });

        it('should fire cancel event', function() {
            expect(spy.calledOnce).to.be.ok();
        });

        // phantom hasn't fullscreen
        if (DG.screenfull.api['fullscreenElement']) {
            it('should disable fullscreen', function() {
                expect(document[DG.screenfull.api['fullscreenElement']]).to.be(null);
            });
        }

        it('should container hasn\'t active class', function() {
            expect(container.className).not.to.contain('active');
        });
    });
});


================================================
FILE: src/DGGeoclicker/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>
    <title>geoclicker demo</title>
    <script src="http://maps.api.2gis.dev/2.0/loader.js"></script>
    <style type="text/css">
        html,body { height: 100%; margin: 0; padding: 0; }
        #map { width: 100%; height: 100%; }
    </style>
</head>
<body>
    <div id="map"></div>

    <script type="text/javascript">
        DG.then(function () {
            map = new DG.Map('map', {
                center: new DG.LatLng(54.980206086231, 82.898068362003),
                zoom: 18,
                key: DG.config.key || 'Your API access key',
                geoclicker: {
                    showPhotos: true,
                    showBooklet: true,
                    showRouteSearch: true
                }
            });
        });
    </script>
</body>
</html>


================================================
FILE: src/DGGeoclicker/lang/cs.js
================================================
DG.Geoclicker.Handler.Default.Dictionary.cs = DG.extend({
    apiErrorTitle: 'Chybička se&nbsp;vloudila',
    apiErrorBody: 'Naše servery odmítají reagovat. Již nyní vynakládáme veškeré úsilí, abychom je přivedli k rozumu. Zkuste akci opakovat za několik minut.',
    we_have_not : 'O tomto místě zatím nemáme informace',
    noname : 'Bez názvu',
    'adm_div.place' : 'Místo',
    'adm_div.division' : 'Správní obvod',
    'adm_div.settlement' : 'Obec',
    street : 'Ulice',
    'adm_div.district' : 'Městská část',
    'adm_div.city' : 'Město',
    go_to : 'Cesta sem',
    show_organization_in_building : ['Celkem {n} organizace', 'Celkem {n} organizace', 'Celkem {n} organizací'],
    back_button : 'Zpět',
    show_more_about_sight : 'Více',
    n_floors : ['{n} patro', '{n} patra', '{n} pater']
}, DG.Dictionary.cs);


================================================
FILE: src/DGGeoclicker/lang/en.js
================================================
DG.Geoclicker.Handler.Default.Dictionary.en = DG.extend({
    apiErrorTitle: 'Oops! Error detected.',
    apiErrorBody: 'Our servers are not responding. We are doing our best to straighten them out. Please return to us in a few minutes.',
    we_have_not: 'We haven\'t collected info about this place yet',
    noname : 'No name',
    'adm_div.place' : 'Place',
    'adm_div.division' : 'Area',
    'adm_div.settlement' : 'Village',
    street : 'Street',
    'adm_div.district' : 'District',
    'adm_div.city' : 'City',
    go_to : 'Directions to here',
    show_organization_in_building : ['{n} organization total', '{n} organizations total'],
    back_button : 'Back',
    show_more_about_sight : 'More information',
    n_floors : ['{n} floor', '{n} floors']
}, DG.Dictionary.en);


================================================
FILE: src/DGGeoclicker/lang/es.js
================================================
DG.Geoclicker.Handler.Default.Dictionary.es = DG.extend({
    apiErrorTitle: 'Vaya, ha ocurrido un error',
    apiErrorBody: 'Nuestros servidores se niegan a responder. Ya nos estamos esforzando por hacerlos entrar en razón. Vuelva con nosotros pasados unos minutos.',
    we_have_not : 'Todavía no hemos recopilado la información sobre este lugar',
    noname : 'Sin nombre',
    'adm_div.place' : 'Lugar',
    'adm_div.division' : 'Comuna',
    'adm_div.settlement' : 'Población',
    street : 'Calle',
    'adm_div.district' : 'Comuna',
    'adm_div.city' : 'Ciudad',
    go_to : 'Ir para allá',
    show_organization_in_building : ['Total {n} organización', 'Total {n} organizaciones', 'Total {n} organizaciones'],
    show_more_about_sight : 'Read more',
    back_button: 'Atrás',
    n_floors : ['{n} piso', '{n} pisos']
}, DG.Dictionary.es);


================================================
FILE: src/DGGeoclicker/lang/it.js
================================================
DG.Geoclicker.Handler.Default.Dictionary.it = DG.extend({
    apiErrorTitle: 'Oh oh, c\'è&nbsp;un&nbsp;errore',
    apiErrorBody: 'I nostri server si rifiutano di rispondere. Stiamo facendo del nostro meglio per convincerli a&nbsp;comportarsi bene. Ritorna tra qualche minuto.',
    we_have_not : 'Non disponiamo ancora di informazioni su questo posto',
    noname : 'Nome non indicato',
    'adm_div.place' : 'Luogo',
    'adm_div.division' : 'Zona',
    'adm_div.settlement' : 'Comune',
    street : 'Via',
    'adm_div.district' : 'Municipalità',
    'adm_div.city' : 'Сittà',
    go_to : 'Come arrivare',
    show_organization_in_building : ['{n} azienda in tutto', '{n} aziende in tutto'],
    show_more_about_sight : 'Maggiori informazioni',
    back_button: 'Indietro',
    n_floors : ['{n} piano', '{n} piani']
}, DG.Dictionary.it);


================================================
FILE: src/DGGeoclicker/lang/ru.js
================================================
DG.Geoclicker.Handler.Default.Dictionary.ru = DG.extend({
    apiErrorTitle: 'Ошибочка вышла',
    apiErrorBody: 'Наши серверы отказываются отвечать. Мы уже прикладываем все силы, чтобы вразумить их. Возвращайтесь к&nbsp;нам через&nbsp;несколько минут.',
    we_have_not : 'Это место мы ещё не успели изучить',
    noname: 'Без названия',
    'adm_div.place': 'Место',
    'adm_div.division': 'Округ',
    'adm_div.settlement': 'Населенный пункт',
    street: 'Улица',
    'adm_div.district': 'Район',
    'adm_div.city': 'Город',
    go_to: 'Проехать сюда',
    show_organization_in_building: ['Всего {n} организация', 'Всего {n} организации', 'Всего {n} организаций'],
    show_more_about_sight: 'Подробнее',
    back_button: 'Назад',
    n_floors: ['{n} этаж', '{n} этажа', '{n} этажей']
}, DG.Dictionary.ru);


================================================
FILE: src/DGGeoclicker/skin/basic/less/dg-building-callout.less
================================================
.dg-building-callout__body {
    position: relative;
}

.dg-building-callout__list {
    margin-bottom: 8px;
    padding-left: 24px;
    color: #ffe6aa;
    list-style: none;
}

.dg-building-callout__list-item {
    position: relative;
    margin-bottom: 4px;
    font-size: 12px;

    &:before {
        position: absolute;
        top: 5px;
        left: -21px;
        content: '';
    }
}


================================================
FILE: src/DGGeoclicker/skin/basic/less/dg-firm-card.less
================================================
.dg-firm-card__icon {
    position: relative;
    padding-left: 24px;

    &:before {
        position: absolute;
        top: 0;
        left: 0;
        margin: auto;
        background-position: 0 50%;
        background-repeat: no-repeat;
        content: '';
    }
}

.dg-firm-card__link {
    overflow: hidden;
    margin-bottom: 4px;
    text-overflow: ellipsis;
    white-space: nowrap;
    word-wrap: normal;
    line-height: 16px;
}

.dg-firm-card__link a {
    background-position: center bottom;
    background-size: 10px 1px;
    background-repeat: repeat-x;
    text-decoration: none;
}

.dg-firm-card__address {
    margin-bottom: 10px;
    font-size: 16px;

    &:before {
        position: absolute;
        top: 5px;
        left: 1px;
        content: '';
    }
}

.dg-firm-card__comment {
    position: relative;
    margin-left: 5px;
    font-size: 12px;
}

.dg-firm-card__phone {
    overflow: hidden;
    margin-bottom: 4px;
    text-overflow: ellipsis;
    line-height: 16px;

    &:before {
        top: 3px;
        left: 1px;
    }
}

.dg-firm-card__site {
    &:before {
        top: 3px;
    }
}

.dg-firm-card__email {
    &:before {
        top: 5px;
        height: 7px;
    }
}

.dg-firm-card__rubrics {
    overflow: hidden;
    margin-bottom: 4px;
    font-size: 12px;
    line-height: 16px;
}

.dg-firm-card__rubrics-list {
    margin: 0;
    padding: 0;
    list-style: none;
}

.dg-firm-card__rubrics-list-item {
    display: inline;
    cursor: default;

    &:before {
        display: inline-block;
        margin: 0 4px;
        content: '•';
    }

    &:first-child:before {
        margin: 0;
        content: '';
    }
}

.dg-firm-card__aa {
    margin: 0 0 4px;
    padding: 0 0 0 24px;
    font-size: 12px;
}

.dg-firm-card__aa-list {
    display: inline;
    margin: 0;
    padding: 0;
    list-style: none;
    line-height: 16px;
}

.dg-firm-card__aa-list-item {
    display: inline;
    box-sizing: border-box;
    max-width: 100%;
    cursor: default;

    &:before {
        display: inline-block;
        margin: 0 4px;
        content: '•';
    }

    &:first-child:before {
        margin: 0;
        content: '';
    }
}

.dg-firm-card__aa-list-additional {
    display: inline;
    margin: 0;
    padding: 0;
    list-style: none;
    line-height: 16px;
}

.dg-firm-card__schedule {
    margin-bottom: 10px;
}


================================================
FILE: src/DGGeoclicker/skin/basic/less/dg-link.less
================================================
.dg-link,
.dg-link:hover {
    background-position: 0 95%;
    background-size: 10px 1px;
    background-repeat: repeat-x;
}

.dg-link_type_local {
    background: linear-gradient(to right, #99ccdd, #99ccdd 50%, transparent 50%);

    .no-touch &:hover {
        background: linear-gradient(to right, #99bbcc, #99bbcc 50%, transparent 50%);
    }
}

.dg-link.dg-link_type_local,
.dg-link.dg-link_type_local:hover {
    background-size: 6px 1px;
}


================================================
FILE: src/DGGeoclicker/skin/basic/less/dg-map-geoclicker.less
================================================
.dg-map-geoclicker__address {
    margin-bottom: 10px;
    font-size: 16px;

    .dg-map-geoclicker__purpose + & {
        margin-top: -6px;
    }
}

.dg-map-geoclicker__address-header {
    position: relative;
    margin-bottom: 4px;
    padding-left: 24px;

    &:first-child:before {
        position: absolute;
        top: 5px;
        left: 1px;
        content: '';
    }
}

.dg-map-geoclicker__address-drilldown {
    position: relative;
    margin-bottom: 4px;
    padding-left: 24px;
    color: #aaa;
    font-size: 12px;

    &:first-child:before {
        position: absolute;
        top: 2px;
        left: 1px;
        content: '';
    }
}

.dg-map-geoclicker__purpose {
    position: relative;
    margin-bottom: 10px;
    padding-left: 24px;
    font-size: 16px;

    .dg-map-geoclicker__address + & {
        margin-top: -6px;
    }

    &:before {
        position: absolute;
        top: 4px;
        left: 2px;
        content: '';
    }

    &_type_street:before {
        top: 4px;
    }
}

.dg-map-geoclicker__sight-description {
    overflow: hidden;
    padding: .5em 0 0 24px;
    max-height: 3.6em;
}

a.dg-map-geoclicker__show-more-sights-link {
    position: relative;
    margin-left: 24px;
    border-bottom: 1px dotted;
    text-decoration: none;

    &:after {
        position: absolute;
        top: 4px;
        margin-left: 5px;
        width: 6px;
        height: 10px;
        content: '';
        font-weight: bold;
    }
}

.dg-map-geoclicker__clamped-line {
    display: block;
    white-space: nowrap;
}

.dg-map-geoclicker__clamped-line_last {
    overflow: hidden;
    width: 100%;
    text-overflow: ellipsis;
}

.dg-map-geoclicker__preloader-wrapper {
    display: table-cell;
    vertical-align: middle;
    text-align: center;
}

.dg-map-geoclicker__drilldown {
    margin-bottom: 10px;
}


================================================
FILE: src/DGGeoclicker/skin/basic/less/dg-popup.ie.less
================================================
.dg-popup__header-title_for_firmcard {
    max-height: none;
}


================================================
FILE: src/DGGeoclicker/skin/basic/less/dg-popup.less
================================================
.dg-popup__footer-buttons {
    display: table;
    margin-top: 10px;
    width: 100%;
}

.dg-popup__footer-button-wrapper {
    display: table-cell;
}

.dg-popup__footer-button {
    position: relative;
    display: inline-block;
    box-sizing: border-box;
    margin-left: 5%;
    width: 95%;
    border-radius: 2px;
    text-align: center;
    text-decoration: none;
    font: 12px/24px Arial, sans-serif;
    cursor: pointer;
    transition: all .1s;

    .dg-popup__footer-button-wrapper:first-child & {
        margin: 0;
        width: 100%;
    }

    .no-touch &:hover {
        transition: all .2s; /* @TODO: all? */
    }
}

.dg-popup__footer-icon-button:before {
    display: inline-block;
    margin: -2px 5px 0 0;
    width: 12px;
    height: 12px;
    background-size: contain;
    background-repeat: no-repeat;
    content: '';
    vertical-align: middle;
}

.dg-popup__button_name_goto:before {
    width: 20px;
    height: 7px;
}

.dg-popup__button_name_firm-card-back:before {
    width: 9px;
    height: 6px;
}

.dg-popup__button_name_firm-list-back:before {
    width: 9px;
    height: 6px;
}

.dg-popup__button_name_back:before {
    width: 9px;
    height: 6px;
}

.dg-popup__show-less-house-link {
    position: relative;
    top: 6px;
    margin: 0 15px 10px;
    color: #0070c0;
    text-decoration: none;
    font-size: 12px;
    line-height: 24px;
}

.dg-popup__header-links {
    margin: 8px 18px 0 0;
}

.dg-popup__header-title_for_firmcard {
    position: relative;
    overflow: hidden;
    max-height: 3.4em;
}

.dg-popup__header-teaser {
    display: -webkit-box;
    height: 3.3em;
    -webkit-line-clamp: 3;
    -webkit-box-orient: vertical;
}

.dg-popup__header-title {
    display: block;
    white-space: normal;
    font: 22px/24px 'Arial narrow', Arial, sans-serif;
}

.dg-popup__header-link {
    display: inline-block;
    margin-left: 2.6em;
    vertical-align: middle;
    white-space: nowrap;

    &:first-child {
        margin-left: 1.2em;
    }
}

.dg-popup__rating {
    display: inline-block;
    margin: 0 .4em 3px 0;
    width: 70px;
    height: 14px;
    vertical-align: middle;
}

.dg-popup__rating-stars {
    .repeatableBg('DGPopup__ratingStar');
    float: left;
    height: 100%;
}

.dg-popup__link {
    position: relative;
    background-position: center bottom;
    background-size: 10px 1px;
    background-repeat: repeat-x;
    text-decoration: none;
    -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
}

.dg-popup__link_type_flamp_reviews {
    margin-left: .1em;
}

.dg-popup__link_type_photos:before {
    position: absolute;
    top: 2px;
    left: -18px;
    display: inherit;
    content: '';
}

.dg-popup__link_type_booklet:before {
    .notRepeatableBgWithSizes('DGPopup__bookletLinkIcon');
    position: absolute;
    top: 2px;
    left: -18px;
    display: inherit;
    content: '';
}


================================================
FILE: src/DGGeoclicker/skin/basic/less/dg-preloader.less
================================================
.dg-preloader {
    position: relative;
    margin: 0 auto;
    width: 200px;
    height: 44px;
    vertical-align: middle;
}

.dg-preloader_animation_false {
    .notRepeatableBg('DGPreloader__preloader');
    background-attachment: scroll;
    background-position: 50% 50%;
}

.dg-preloader_animation_true {
    &:before {
        position: absolute;
        top: 50%;
        left: 50%;
        margin: -22px 0 0 -22px;
        width: 44px;
        height: 44px;
        outline: 1px solid transparent;
        content: '';
        animation: dg-preloader__outer 5s linear infinite;
        image-rendering: optimizeQuality;
    }

    &.dg-preloader_size_small:before {
        margin: -12px 0 0 -12px;
        width: 24px;
        height: 24px;
    }

    &.dg-preloader_scheme_regular:before {
        .notRepeatableBg('DGPreloader__preloaderBig', true);
        background-size: 44px 44px;
    }

    &.dg-preloader_scheme_regular.dg-preloader_size_small:before {
        .notRepeatableBg('DGPreloader__preloaderSmall', true);
        background-size: 24px 24px;
    }

    &:after {
        position: absolute;
        top: 50%;
        left: 50%;
        margin: -16px 0 0 -16px;
        width: 32px;
        height: 32px;
        outline: 1px solid transparent;
        content: '';
        animation: dg-preloader__inner 4s linear infinite;
        image-rendering: optimizeQuality;
    }

    &.dg-preloader_size_small:after {
        margin: -6px 0 0 -6px;
        width: 12px;
        height: 12px;
    }

    &.dg-preloader_scheme_regular:after {
        .notRepeatableBg('DGPreloader__preloaderBigInner', true);
        background-size: 32px 32px;
    }

    &.dg-preloader_scheme_regular.dg-preloader_size_small:after {
        .notRepeatableBg('DGPreloader__preloaderSmallInner', true);
        background-size: 12px 12px;
    }
}

@keyframes dg-preloader__outer {
    to {
        transform: rotate(360deg);
    }
}

@keyframes dg-preloader__inner {
    to {
        transform: rotate(-360deg);
    }
}


================================================
FILE: src/DGGeoclicker/skin/basic/less/dg-schedule.ie.less
================================================
.dg-schedule__today_shown_true:after {
    content: ' ';
}


================================================
FILE: src/DGGeoclicker/skin/basic/less/dg-schedule.less
================================================
.dg-schedule {
}

.dg-schedule__today {
    position: relative;
    display: inline-block;
    margin-left: 24px;
    max-width: 84%;
    background-position: center bottom;
    background-size: 2px 1px;
    background-repeat: repeat-x;
    font-size: 14px;
    line-height: 16px;
    cursor: pointer;

    &:before {
        position: absolute;
        top: 3px;
        left: -24px;
        content: '';
    }

    &:after {
        position: absolute;
        right: -15px;
        bottom: 4px;
        content: '';
    }
}

.dg-schedule__today-inner {
    overflow: hidden;
    width: 100%;
    text-overflow: ellipsis;
    white-space: nowrap;
}

.dg-schedule_works-everyday_true .dg-schedule__today {
    background-image: none;
    cursor: default;

    &:after {
        background-image: none;
    }
}

.dg-schedule_open_true .dg-schedule__today:before {
    .notRepeatableBgWithSizes('DGSchedule__clockOn');
}

.dg-schedule__now {
    margin: 2px 7px 0 36px;
    font-size: 12px;
}

.dg-schedule__string {
    padding: 3px 16px 3px 24px;
    text-align: left;
    font-size: 14px;
}

.dg-schedule__string-time {
    white-space: nowrap;
}

.dg-schedule__table {
    display: none;
    text-align: center;
    font-size: 0;
}

.dg-schedule__table-cell-group {
    white-space: nowrap;
}

.dg-schedule__tc {
    display: inline-block;
    padding: 2px 0 15px;
    width: 44px;
    vertical-align: top;
    white-space: normal;
    font-size: 14px;
}

.dg-schedule__tc_pre {
    width: 19px;
}

.dg-schedule__day-name {
    margin: 0;
    color: #8c8782;
    text-transform: capitalize;
}

.dg-schedule__td {
    margin: 10px 0 0;
}

.dg-schedule_state_expanded .dg-schedule__popup {
    display: block;
    visibility: visible;
    max-height: 1000px;
    opacity: 1;
}

.dg-schedule__table-clock {
    margin: 13px 0 0 0;
}

.dg-schedule__table-lunch {
    margin: 31px 0 0 0;
}

.dg-schedule_open_true {
}

.dg-schedule_state_expanded {
}

.dg-schedule_works-everyday_true {
}


================================================
FILE: src/DGGeoclicker/skin/dark/less/dg-building-callout.less
================================================
.dg-building-callout__list-item:before {
    .notRepeatableBgWithSizes('DGBuildingCallout__bullet_dark');
}


================================================
FILE: src/DGGeoclicker/skin/dark/less/dg-firm-card.less
================================================
.dg-firm-card__link a {
    background-image: linear-gradient(to right, rgba(255, 230, 170, .3), rgba(255, 230, 170, .3) 100%);
    color: #ffe6aa;

    .no-touch &:hover {
        background-image: linear-gradient(to right, rgba(153, 204, 221, .3), rgba(153, 204, 221, .3) 100%);
        color: #9cd;
    }
}

.dg-firm-card__comment {
    color: #aaa;
}

.dg-firm-card__rubrics {
    color: #aaa;
}

.dg-firm-card__rubrics-list-item:after {
    color: #6e6964;
}

.dg-firm-card__aa-list-item:after {
    color: #e6e6e6;
}

.dg-firm-card__address:before {
    .notRepeatableBgWithSizes('DGBuildingCallout__marker_dark');
}

.dg-firm-card__phone:before {
    .notRepeatableBgWithSizes('DGFirmCard__phoneIcon_dark');
}

.dg-firm-card__site:before {
    .notRepeatableBgWithSizes('DGFirmCard__siteIcon_dark');
}

.dg-firm-card__email:before {
    .notRepeatableBgWithSizes('DGFirmCard__mailIcon_dark');
}


================================================
FILE: src/DGGeoclicker/skin/dark/less/dg-map-geoclicker.less
================================================
.dg-map-geoclicker__address-header:first-child:before,
.dg-map-geoclicker__address-drilldown:first-child:before {
    .notRepeatableBgWithSizes('DGBuildingCallout__marker_dark');
}

.dg-map-geoclicker__purpose {
    &:before {
        .notRepeatableBgWithSizes('DGGeoclicker__purpose_dark');
    }

    &_type_street:before {
        .notRepeatableBgWithSizes('DGGeoclicker__purposeStreet_dark');
    }

    &_type_sight:before {
        .notRepeatableBgWithSizes('DGGeoclicker__purposeSight_dark');
    }

    &_type_settlement:before {
        .notRepeatableBgWithSizes('DGGeoclicker__purposeSettlement_dark');
    }
}

a.dg-map-geoclicker__show-more-sights-link {
    color: #ffe6aa;

    .no-touch &:hover {
        color: #9cd;
    }

    &:after {
        .notRepeatableBg('DGGeoclicker__arrowLeft_dark');
    }
}

.dg-map-geoclicker__drilldown {
    color: #aaa;
}


================================================
FILE: src/DGGeoclicker/skin/dark/less/dg-popup.ie.less
================================================
.dg-popup__footer-button {
    background-color: #373737;
}


================================================
FILE: src/DGGeoclicker/skin/dark/less/dg-popup.less
================================================
a.dg-popup__link {
    background-image: linear-gradient(to right, rgba(255, 230, 170, .3), rgba(255, 230, 170, .3) 100%);
    color: #ffe6aa;

    .no-touch &:hover {
        background-image: linear-gradient(to right, rgba(153, 204, 221, .3), rgba(153, 204, 221, .3) 100%);
        color: #9cd;
    }
}

.dg-popup__header-title {
    color: #ffc84b;
}

.dg-popup__footer-button-wrapper .dg-popup__footer-button,
.dg-popup__footer-button-wrapper .dg-popup__footer-button:hover {
    color: #e6e6e6;
}

.dg-popup__footer-button {
    background: rgba(0, 0, 0, .2);
    box-shadow: 0 1px rgba(0, 0, 0, .1);

    .no-touch &:hover {
        background: #222;
        box-shadow: 0 1px 3px rgba(0, 0, 0, .5);
    }
}

.dg-popup__rating {
    .repeatableBg('DGPopup__ratingStarOff_dark');
}

.dg-popup__link_type_photos:before {
    .notRepeatableBgWithSizes('DGPopup__photoIcon_dark');
}

.dg-popup__button_name_firm-card-back:before {
    .notRepeatableBg('DGPopup__backIcon_dark');
}

.dg-popup__button_name_firm-list-back:before {
    .notRepeatableBg('DGPopup__backIcon_dark');
}

.dg-popup__button_name_back:before {
    .notRepeatableBgWithSizes('DGPopup__backIcon_dark');
}

.dg-popup__button_name_goto:before {
    .notRepeatableBgWithSizes('DGPopup__pathIcon_dark');
}

.dg-popup__button_name_show-entrance:before {
    .notRepeatableBg('DGPopup__entranceIcon_dark');
}


================================================
FILE: src/DGGeoclicker/skin/dark/less/dg-schedule.ie.less
================================================
.dg-schedule__tc_active_true {
    .gradient(rgba(255, 255, 255, .4), rgba(255, 255, 255, .4));
}

.dg-schedule__tc_active_true > .dg-schedule__day-name {
    color: #e6e6e6;
}


================================================
FILE: src/DGGeoclicker/skin/dark/less/dg-schedule.less
================================================
.dg-schedule__today {
    background-image: linear-gradient(to right,
    rgba(230, 230, 230, .55),
    rgba(230, 230, 230, .55) 50%,
    rgba(0, 0, 0, .0) 51%,
    rgba(0, 0, 0, .0) 100%
    );
}

.dg-schedule__now {
    color: #aaa;
}

.dg-schedule__td {
    color: #e6e6e6;
}

.dg-schedule__tc_active_true {
    background: rgba(255, 255, 255, .1);
}

.dg-schedule__string-time {
    color: #e6e6e6;
}

.dg-schedule__table-clock {
    .notRepeatableBgWithSizes('DGSchedule__clockOff_dark');
}

.dg-schedule__table-lunch {
    .notRepeatableBgWithSizes('DGSchedule__lunchIcon_dark');
}

.dg-schedule_open_false .dg-schedule__today:before {
    .notRepeatableBgWithSizes('DGSchedule__clockOff_dark');
}

.dg-schedule__today:after {
    .notRepeatableBgWithSizes('DGSchedule__expandIcon_dark');
}

.dg-schedule__today_shown_true:after {
    .notRepeatableBgWithSizes('DGSchedule__collapseIcon_dark');
}


================================================
FILE: src/DGGeoclicker/skin/light/less/dg-building-callout.less
================================================
.dg-building-callout__list-item:before {
    .notRepeatableBgWithSizes('DGBuildingCallout__bullet_light');
}


================================================
FILE: src/DGGeoclicker/skin/light/less/dg-firm-card.less
================================================
.dg-firm-card__link a {
    background-image: linear-gradient(to right, rgba(0, 91, 143, .3), rgba(0, 91, 143, .3) 100%);
    color: #005b8f;

    .no-touch &:hover {
        background-image: linear-gradient(to right, rgba(0, 0, 0, .3), rgba(0, 0, 0, .3) 100%);
        color: #000;
    }
}

.dg-firm-card__comment {
    color: #666;
}

.dg-firm-card__rubrics {
    color: #666;
}

.dg-firm-card__rubrics-list-item:after {
    color: #666;
}

.dg-firm-card__address:before {
    .notRepeatableBgWithSizes('DGBuildingCallout__marker_light');
}

.dg-firm-card__phone:before {
    .notRepeatableBgWithSizes('DGFirmCard__phoneIcon_light');
}

.dg-firm-card__site:before {
    .notRepeatableBgWithSizes('DGFirmCard__siteIcon_light');
}

.dg-firm-card__email:before {
    .notRepeatableBgWithSizes('DGFirmCard__mailIcon_light');
}


================================================
FILE: src/DGGeoclicker/skin/light/less/dg-map-geoclicker.less
================================================
.dg-map-geoclicker__address-header:first-child:before,
.dg-map-geoclicker__address-drilldown:first-child:before {
    .notRepeatableBgWithSizes('DGBuildingCallout__marker_light');
}

.dg-map-geoclicker__purpose {
    &:before {
        .notRepeatableBgWithSizes('DGGeoclicker__purpose_light');
    }

    &_type_street:before {
        .notRepeatableBgWithSizes('DGGeoclicker__purposeStreet_light');
    }

    &_type_sight:before {
        .notRepeatableBgWithSizes('DGGeoclicker__purposeSight_light');
    }

    &_type_settlement:before {
        .notRepeatableBgWithSizes('DGGeoclicker__purposeSettlement_light');
    }
}

a.dg-map-geoclicker__show-more-sights-link {
    color: #005b8f;

    .no-touch &:hover {
        color: #000;
    }

    &:after {
        .notRepeatableBg('DGGeoclicker__arrowLeft_light');
    }
}

.dg-map-geoclicker__drilldown {
    color: #666;
}


================================================
FILE: src/DGGeoclicker/skin/light/less/dg-popup.less
================================================
a.dg-popup__link {
    background-image: linear-gradient(to right, rgba(0, 91, 143, .3), rgba(0, 91, 143, .3) 100%);
    color: #005b8f;

    .no-touch &:hover {
        background-image: linear-gradient(to right, rgba(0, 0, 0, .3), rgba(0, 0, 0, .3) 100%);
        color: #000;
    }
}

.dg-popup__footer-button-wrapper .dg-popup__footer-button {
    color: #647882;

    .no-touch &:hover {
        color: #286482;
    }
}

.dg-popup__footer-button {
    border: 1px solid #e9edf2;
    background: #f5faff;
    box-shadow: 0 1px rgba(0, 0, 0, .1);

    .no-touch &:hover {
        background: #e7f3ff;
    }
}

.dg-popup__rating {
    .repeatableBg('DGPopup__ratingStarOff_light');
}

.dg-popup__link_type_photos:before {
    .notRepeatableBgWithSizes('DGPopup__photoIcon_light');
}

.dg-popup__button_name_firm-card-back:before {
    .notRepeatableBgWithSizes('DGPopup__backIcon_light');
}

.dg-popup__button_name_firm-list-back:before {
    .notRepeatableBgWithSizes('DGPopup__backIcon_light');
}

.dg-popup__button_name_back:before {
    .notRepeatableBgWithSizes('DGPopup__backIcon_light');
}

.dg-popup__button_name_goto:before {
    .notRepeatableBg('DGPopup__pathIcon_light');
}

.dg-popup__button_name_show-entrance:before {
    .notRepeatableBg('DGPopup__entranceIcon_light');
}



================================================
FILE: src/DGGeoclicker/skin/light/less/dg-schedule.ie.less
================================================
.dg-schedule__tc_active_true {
    .gradient(rgba(230, 230, 230, .4), rgba(230, 230, 230, .4));
}


================================================
FILE: src/DGGeoclicker/skin/light/less/dg-schedule.less
================================================
.dg-schedule__today {
    background-image: linear-gradient(to right,
    rgba(0, 0, 0, .55),
    rgba(0, 0, 0, .55) 50%,
    rgba(0, 0, 0, .0) 51%,
    rgba(0, 0, 0, .0) 100%
    );
}

.dg-schedule__now {
    color: #666;
}

.dg-schedule__td {
    color: #000;
}

.dg-schedule__tc_active_true {
    background: rgba(0, 0, 0, .03);
}

.dg-schedule__string-time {
    color: #666;
}

.dg-schedule__table-clock {
    .notRepeatableBgWithSizes('DGSchedule__clockOff_light');
}

.dg-schedule__table-lunch {
    .notRepeatableBgWithSizes('DGSchedule__lunchIcon_light');
}

.dg-schedule_open_false .dg-schedule__today:before {
    .notRepeatableBgWithSizes('DGSchedule__clockOff_light');
}

.dg-schedule__today:after {
    .notRepeatableBgWithSizes('DGSchedule__expandIcon_light');
}

.dg-schedule__today_shown_true:after {
    .notRepeatableBgWithSizes('DGSchedule__collapseIcon_light');
}


================================================
FILE: src/DGGeoclicker/src/ClampHelper.js
================================================
DG.Geoclicker.clampHelper = function(el, lineClamp) {
    var measure, text, lineWidth,
        lineStart, lineCount, wordStart,
        line, lineText, wasNewLine,
        ce = document.createElement.bind(document),
        ctn = document.createTextNode.bind(document);

    // measurement element is made a child of the clamped element to get it's style
    measure = ce('span');

    (function(s) {
        s.position = 'absolute'; // prevent page reflow
        s.whiteSpace = 'pre'; // cross-browser width results
        s.visibility = 'hidden'; // prevent drawing
        s.margin = '0 18px 8px 0';
    })(measure.style);

    // make sure the element belongs to the document
    if (!el.ownerDocument || el.ownerDocument !== document) {
        return;
    }
    // reset to safe starting values
    lineStart = wordStart = 0;
    lineCount = 1;
    wasNewLine = false;
    lineWidth = el.clientWidth;
    // get all the text, remove any line changes
    text = (el.textContent || el.innerText).replace(/\n/g, ' ');
    // remove all content
    while (el.firstChild !== null) {
        el.removeChild(el.firstChild);
    }
    // add measurement element within so it inherits styles
    el.appendChild(measure);
    // http://ejohn.org/blog/search-and-dont-replace/
    text.replace(/ |-/g, function(m, pos) {
        // ignore any further processing if we have total lines
        if (lineCount === lineClamp) {
            return;
        }
        // create a text node and place it in the measurement element
        measure.appendChild(ctn(text.substr(lineStart, pos - lineStart)));
        // have we exceeded allowed line width?
        if (lineWidth < measure.clientWidth) {
            if (wasNewLine) {
                // we have a long word so it gets a line of it's own
                lineText = text.substr(lineStart, pos + 1 - lineStart);
                // next line start position
                lineStart = pos + 1;
            } else {
                // grab the text until this word
                lineText = text.substr(lineStart, wordStart - lineStart);
                // next line start position
                lineStart = wordStart;
            }
            // create a line element
            line = ce('span');
            // add text to the line element
            line.appendChild(ctn(lineText));
            // add the line element to the container
            el.appendChild(line);
            line.className = 'dg-map-geoclicker__clamped-line';
            // yes, we created a new line
            wasNewLine = true;
            lineCount++;
        } else {
            // did not create a new line
            wasNewLine = false;
        }
        // remember last word start position
        wordStart = pos + 1;
        // clear measurement element
        measure.removeChild(measure.firstChild);
    });
    // remove the measurement element from the container
    el.removeChild(measure);
    // create the last line element
    line = ce('span');
    // give styles required for text-overflow to kick in
    line.className = 'dg-map-geoclicker__clamped-line dg-map-geoclicker__clamped-line_last';
    // add all remaining text to the line element
    line.appendChild(ctn(text.substr(lineStart)));
    // add the line element to the container
    el.appendChild(line);
};


================================================
FILE: src/DGGeoclicker/src/Controller.js
================================================
DG.Geoclicker.Controller = DG.Class.extend({

    options: {
        // if handler worked successfully, it should return rendering object that will be processed in View , otherwise it should return false
        // default handler always should return rendering object
        'handlersSequence': {
            'poi': DG.Geoclicker.Handler.Poi,
            'attraction': DG.Geoclicker.Handler.Sight,
            'building': DG.Geoclicker.Handler.House,
            'street': DG.Geoclicker.Handler.CityArea,
            'adm_div.place': DG.Geoclicker.Handler.CityArea,
            'adm_div.district': DG.Geoclicker.Handler.CityArea,
            'adm_div.division': DG.Geoclicker.Handler.CityArea,
            'adm_div.settlement': DG.Geoclicker.Handler.CityArea,
            'adm_div.city': DG.Geoclicker.Handler.CityArea,

            'default': DG.Geoclicker.Handler.Default,

            'apiError': DG.Geoclicker.Handler.ApiError

            // station_platform
            // project
            // station
            // crossbroad
            // metro
        }
    },

    initialize: function(map, options) { // (Object, Object)
        this._options = options;
        this._handlers = {};
        this._catalogApi = new DG.Geoclicker.Provider.CatalogApi(map);
        this._map = map;
        this._view = new DG.Geoclicker.View(map);

        this._renderHandlerResult = DG.bind(this._renderHandlerResult, this);
        this._lastHandleClickArguments = null;
        this._hasCatalogKey = false;
    },

    handlePopupClose: function(popup) { // (Object)
        if (popup === this._view.getPopup()) {
            this._lastHandleClickArguments = null;
            this._catalogApi.cancelLastRequest();
        }
    },

    handleClick: function(latlng, zoom, meta) { // (Object, Number, Object)
        var self = this,
            args = Array.prototype.slice.call(arguments, 0);

        function initShowPopup() {
            var loader = self._view.initLoader();
            self._view._popup.clear();
            self._view.showPopup(latlng, loader);
            self._lastHandleClickArguments = args;
        }

        if (meta && meta.linked && meta.linked.type != 'sight' && meta.linked.type != 'attraction') {
            if (meta.linked.type != 'branch' && meta.linked.type != 'building') {
                return;
            }

            initShowPopup();
            self.handleResponse({
                poi: {
                    reference: meta.linked
                }
            });
        } else {
            this._catalogApi.getLocations({
                latlng: latlng,
                zoom: zoom,
                beforeRequest: initShowPopup,
                hasCatalogKey: this._hasCatalogKey,
            }).then(function(result) {
                if (!result['meta'] || result['meta']['code'] !== 403) {
                    initShowPopup();
                    self._hasCatalogKey = true;
                }

                self.handleResponse(result);
            }, function(error) {
                self.handleResponse(error);
            });
        }
    },

    handleResponse: function(result) { // (Object)
        var type;

        if (!result) {
            this._runHandler('default');
            return;
        }

        if (result === 'no type') {
            return;
        }

        if (result === 'aborted') {
            this._runHandler('apiError');
            return;
        }

        type = this.findHandler(result);

        while (type) {
            if (this._runHandler(type, result)) {
                return;
            }
            delete result[type];

            type = this.findHandler(result);
        }
        this._runHandler('default');
    },

    findHandler: function(result) { // (Object) -> String|Null
        for (var i in this.options.handlersSequence) {
            if (result[i]) {
                return i;
            }
        }

        return null;
    },

    getCatalogApi: function() { // () -> Object
        return this._catalogApi;
    },

    getMap: function() {
        return this._map;
    },

    reinvokeHandler: function() {
        if (this._lastHandleClickArguments) {
            this.handleClick.apply(this, this._lastHandleClickArguments);
        }
    },

    _runHandler: function(type, data) { // (String, Object) -> Boolean
        data = data || {};
        this._initHandlerOnce(type);
        this._handlers[type].addClickEvent();

        var handlerResult = this._handlers[type].handle(data, type);

        return handlerResult && handlerResult.then ?
            handlerResult.then(this._renderHandlerResult) :
            handlerResult;
    },

    _renderHandlerResult: function(result) {
        this._view.renderPopup(result);
    },

    _initHandlerOnce: function(type) { // (String)
        if (!this._handlers[type]) {
            this._handlers[type] = new this.options.handlersSequence[type](this, this._view, this._map, this._options);
        }
    }
});


================================================
FILE: src/DGGeoclicker/src/DGGeoclicker.js
================================================
DG.Map.mergeOptions({
    geoclicker: false
});

DG.Geoclicker = DG.Handler.extend({
    clickCount: 0,
    pendingClick: 0,
    timeout: 250, // should be equal to 'delay' value in DoubleTap event

    initialize: function(map, options) { // (Object)
        this._map = map;
        this._controller = new DG.Geoclicker.Controller(map, options);
    },

    addHooks: function() {
        this._toggleEvents(true);

        this._map
            .on('rulerstart', this._pause, this)
            .on('rulerend', this._unpause, this);
    },

    removeHooks: function() {
        this._toggleEvents();

        this._map
            .off('rulerstart', this._pause, this)
            .off('rulerend', this._unpause, this);
    },

    _checkOpenPopup: function() {
        if (DG.Browser.mobile && this._map._popup &&
            (this._map._popup.options.closeOnClick ||
            this._map.options.closePopupOnClick)) {
            this.popupWasOpen = true;
        }
    },

    _pause: function() {
        this._toggleEvents();
    },

    _unpause: function() {
        // Reenable event handling only in case geoclicker is enabled
        if (this.enabled()) {
            this._toggleEvents(true);
        }
    },

    _toggleEvents: function(flag) {
        this._map[flag ? 'on' : 'off'](this._mapEventsListeners, this);
        if (this._map.poi) {
            this._map.poi.getMetaLayer()[flag ? 'on' : 'off']('click', this._onMetaClick, this);
        }
    },

    getController: function() {
        return this._controller;
    },

    _onMetaClick: function(e) {
        this.clickCount = 0;
        clearTimeout(this.pendingClick);
        this.popupWasOpen = false;

        this._mapEventsListeners.click.call(this, e);
    },

    _mapEventsListeners: {
        langchange: function() {
            this._controller.reinvokeHandler();
        },

        popupclose: function(e) { // (Object)
            this._controller.handlePopupClose(e.popup);
        },

        click: function(e) { // (Object)
            if (this.clickCount === 0) {
                this.clickCount = 1;
                this._singleClick(e);
            } else {
                this.clickCount = 0;
                clearTimeout(this.pendingClick);
                this.popupWasOpen = false;
            }
        },

        dblclick: function() {
            if (DG.Browser.ielt9) {
                this.clickCount = 0;
                this.popupWasOpen = false;
                clearTimeout(this.pendingClick);
            }
        }
    },

    _singleClick: function(e) { // (Object)
        var self = this;

        clearTimeout(this.pendingClick);

        this.pendingClick = setTimeout(function() {
            if (e.meta) {
                self._checkOpenPopup();
                self._map.closePopup();
            }

            //  DGPopup's '_close' method is the only place where .popupWasOpen is modified
            //  It signals geoclicker that popup was open before user do a 'click' on map
            //  Multistage behavior is needed as this processing occurs after popup was already closed
            if (!self.popupWasOpen) {
                var zoom = self._map.getZoom();
                self._controller.handleClick(e.latlng, zoom, e.meta);
            }

            self.clickCount = 0;
            self.popupWasOpen = false;
        }, this.timeout);
    }
});

DG.Map.addInitHook('addHandler', 'geoclicker', DG.Geoclicker);


================================================
FILE: src/DGGeoclicker/src/View.js
================================================
DG.Geoclicker.View = DG.Class.extend({

    initialize: function(map, options) { // (Object, Object)
        this._map = map;
        this._popup = DG.popup({
            maxHeight: 300,
            minHeight: 50,
            maxWidth: 385,
            minWidth: 310,
            sprawling: true,
            closeOnClick: true
        });

        if (options) {
            DG.Util.setOptions(this, options);
        }
    },

    initLoader: function(isSmall) {
        var loader = document.createElement('div');
        loader.innerHTML = DG.dust('DGGeoclicker/loader', {
            small: isSmall,
            anim: this._detectCssAnimation()
        });

        return loader.firstChild;
    },

    showPopup: function(latlng, content) { // (Object)
        this._popup
            .setContent(content)
            .setLatLng(latlng)
            .openOn(this._map);
    },

    render: function(options) { // (Object) -> String
        var html,
            data = {};

        options = options || {};
        options.tmpl = options.tmpl || '';

        if (options.data) {
            html = this.renderTemplate(options.tmpl, options.data);
        } else {
            html = options.tmpl;
        }

        if (options.beforeRender) {
            options.beforeRender();
        }

        if (options.popup) {
            if (options.header) {
                data.header = options.header;
            }
            if (options.footer) {
                data.footer = options.footer;
            }
            data.body = html;
            this._popup.setContent(data);
        }
        if (options.afterRender) {
            options.afterRender();
        }

        return html;
    },

    renderTemplate: function(name, data) {
        return DG.dust('DGGeoclicker/' + name, data);
    },

    renderPopup: function(options) { // (Object) -> String
        options.popup = true;
        return this.render(options);
    },

    getPopup: function() { // () -> Object
        return this._popup;
    },

    _detectCssAnimation: function() {
        var animation = false,
            domPrefixes = 'Webkit Moz O ms Khtml'.split(' '),
            elm = document.createElement('div');

        if (elm.style.animationName) { animation = true; }

        if (animation === false) {
            for (var i = 0; i < domPrefixes.length; i++) {
                if (elm.style[domPrefixes[i] + 'AnimationName'] !== undefined) {
                    animation = true;
                    break;
                }
            }
        }
        return animation;
    }
});


================================================
FILE: src/DGGeoclicker/src/handler/ApiError.js
================================================
DG.Geoclicker.Handler.ApiError = DG.Geoclicker.Handler.Default.extend({
    handle: function() { // () -> Promise
        var header = this._view.render({
            tmpl: 'popupHeader',
            data: {
                title: this.t('apiErrorTitle')
            }
        });

        return Promise.resolve({
            header: header,
            tmpl: this.t('apiErrorBody')
        });
    }
});


================================================
FILE: src/DGGeoclicker/src/handler/CityArea.js
================================================
DG.Geoclicker.Handler.CityArea = DG.Geoclicker.Handler.Default.extend({

    _polylineStyleDefault : {
        fillColor: '#ff9387',
        color: '#ff9387',
        noClip: true,
        opacity: 1
    },

    _polylineStyles : {
        11 : {
            fillOpacity: 0.18,
            weight: 1
        },
        12 : {
            fillOpacity: 0.12,
            weight: 1
        },
        13 : {
            fillOpacity: 0.08,
            weight: 2
        },
        18 : {
            fillOpacity: 0,
            weight: 3
        }
    },

    handle: function(results, type) { // (Object, String) -> Promise
        if (!results[type]) {
            return false;
        }

        if (!this._stylesInited) {
            this._initStyles();
        }

        // remove previous geometry see https://github.com/2gis/mapsapi/issues/213
        if (this._geometry) {
            this._map.removeLayer(this._geometry);
        }

        this._popup = this._view.getPopup();

        this._geometryZoomStyle = this._getPolyStyleNum();
        this._geometry = DG.Wkt.geoJsonLayer(results[type].geometry.selection, {
            style: this._polylineStyles[this._geometryZoomStyle],
            interactive: false
        }).addTo(this._map);

        this._map
            .on('zoomend', this._updateGeometry, this)
            .once('popupclose', this._clearPopup, this);

        return Promise.resolve(this._fillCityAreaObject(results, type));
    },

    _fillCityAreaObject: function(results, type) {
        var data = {
            name: this.t('noname'),
            drilldown: '',
            purpose: this.t(type),
            type: type.split('.').join('_')
        };

        data.drilldown = this._getDrilldown(results[type]);

        if (results[type].name) {
            data.name = results[type].name;
        }

        return {
            tmpl: 'cityarea',
            data: data,
            header: this._view.render({
                tmpl: 'popupHeader',
                data: {'title': data.name}
            })
        };
    },

    _initStyles : function() {
        this._stylesInited = true;

        Object.keys(this._polylineStyles).forEach(function(zoom) {
            DG.extend(this._polylineStyles[zoom], this._polylineStyleDefault);
        }, this);
    },

    _getPolyStyleNum: function() {
        var mapZoom = this._map.getZoom();

        return Object.keys(this._polylineStyles).filter(function(zoom) {
            return mapZoom <= zoom;
        })[0] || false;
    },

    _updateGeometry: function() {
        var newStyle = this._getPolyStyleNum();

        if (newStyle && newStyle !== this._geometryZoomStyle) {
            this._geometryZoomStyle = newStyle;
            this._geometry.setStyle(this._polylineStyles[newStyle]);
        }
    },

    _clearPopup: function() {
        this._map
            .removeLayer(this._geometry)
            .off('zoomend', this._updateGeometry, this);
    }

});


================================================
FILE: src/DGGeoclicker/src/handler/Default.js
================================================
DG.Geoclicker.Handler.Default = DG.Class.extend({

    includes: DG.Locale,

    statics: {
        Dictionary: {}
    },

    _eventHandlers: {},

    initialize: function(controller, view, map) { // (Object, Object, Object)
        this._controller = controller;
        this._view = view;
        this._map = map;
    },

    handle: function() { // () -> Promise
        return Promise.resolve({
            tmpl: 'popupHeader',
            data: {'title': this.t('we_have_not')}
        });
    },

    addClickEvent: function() {
        this._view._popup.on('click', this._runEventHandlers, this);
        this._map.once('popupclose', this._removeClickEvent, this);
    },

    _removeClickEvent: function() {
        this._view._popup.off('click', this._runEventHandlers, this);
    },

    _addEventHandler: function(el, handler) { // (String, Function)
        this._eventHandlers[el] = handler;
    },

    _runEventHandlers: function(e) {
        var target = e.originalEvent.target;

        for (var eventClass in this._eventHandlers) {
            if (this._eventHandlers.hasOwnProperty(eventClass) && target.className.indexOf(eventClass) > -1) {
                DG.DomEvent.preventDefault(e.originalEvent);
                this._eventHandlers[eventClass].call(this, target);
                return;
            }
        }
    },

    _clearEventHandlers: function() {
        this._eventHandlers = {};
    },

    _getDirectionsUrl: function(name) {
        var project = this._map.projectDetector.getProject();
        if (!project) {
            return '';
        }

        return DG.Util.template(DG.config.ppnotLink, {
            'domain': project.domain,
            'projectCode': project.code,
            'center': this._map.getCenter().lng + ',' + this._map.getCenter().lat,
            'zoom': this._map.getZoom(),
            'name': encodeURIComponent(name),
            'rsType': project.transport ? 'bus' : 'car',
            'point': this._popup._latlng.lng + ',' + this._popup._latlng.lat
        });
    },

    _getDrilldown: function(object) {
        var admDivs = [],
            result;

        if (object.adm_div) {
            admDivs = object.adm_div
                .reduce(function(admDivs, admDiv) {
                    if (admDiv.name) {
                        admDivs.push(admDiv.name);
                    }

                    return admDivs;
                }, [])
                .reverse();
        }

        if (admDivs.length && object.address && object.address.postcode) {
            admDivs.push(object.address.postcode);
        }

        result = admDivs.join(', ');

        return result;
    }

});


DG.Geoclicker.Handler.HandlerExample = DG.Geoclicker.Handler.Default.extend({

    handle: function(results, type) { // (Object, String) -> Promise
        return Promise.resolve({
            tmpl: type + ':<br/>' + results[type].id
        });
    }
});


================================================
FILE: src/DGGeoclicker/src/handler/Handler.js
================================================
DG.Geoclicker.Handler = {};


================================================
FILE: src/DGGeoclicker/src/handler/House.View.js
================================================
DG.Geoclicker.Handler.House.include({
    _getAddressString: function(house) {
        if (!house.address || !house.address.components) {
            return '';
        }

        return house.address.components
            .filter(function(component) {
                return component.type === 'street_number';
            })
            .map(function(component) {
                return component.street + ', ' + component.number;
            })
            .join(' / ');
    },

    _fillBody: function(house) { // // (Object) -> (DOMElement)
        var data = {},
            wrapper = DG.DomUtil.create('div', 'dg-building-callout__body'),
            filials = house.links && house.links.branches;

        var drilldown = this._getDrilldown(house);

        if (house.building_name) {
            data.address = {
                header: this._getAddressString(house),
                drilldown: drilldown
            };
        } else if (drilldown) {
            data.address = {
                drilldown: drilldown
            };
        }

        data.purpose = house.purpose_name +
            (house.floors ? ', ' + this.t('n_floors', house.floors.ground_count) : '');

        if (filials && filials.count > 0) {
            this._totalPages = Math.ceil(house.links.branches.count / this._firmsOnPage);
        }

        if (house.links && house.links.attractions && house.links.attractions.length) {
            data.attractions = house.links.attractions.reduce(function(attractions, attraction) {
                if (attraction.name) {
                    attractions.push(attraction.name);
                }

                return attractions;
            }, []);
        }

        wrapper.innerHTML = this._view.render({
            tmpl: 'house',
            data: data
        });

        if (filials && filials.items) {
            wrapper.appendChild(this._initShortFirmList(filials.items));
        }

        return wrapper;
    },

    _fillHeader: function(house) { // (Object) -> (HTMLString)
        var header = {};

        if (house.building_name) {
            header.title = house.building_name;
        } else if (house.address && house.address.components) {
            header.title = this._getAddressString(house);
        } else {
            header.title = house.purpose_name;
        }

        this._header = this._view.render({
            tmpl: 'popupHeader',
            data: header
        });

        return this._header;
    },

    _fillFooter: function(house) { // (Object) -> (HTMLString)
        var btns = [];
        var houseFilials = house.links && house.links.branches;
        var filialsItemsCount = houseFilials &&
        houseFilials.items &&
        houseFilials.items.length || 0;

        // Decide if we need to display 'more organisations' button
        if (
            houseFilials &&
            houseFilials.count > filialsItemsCount
        ) {
            btns.push(this._getShowAllData(houseFilials.count));
        }

        if (this._isRouteSearchAllowed()) {
            btns.push({
                name: 'goto',
                label: this.t('go_to'),
                icon: true,
                href: this._directionsUrl
            });
        }

        return this._view.render({
            tmpl: 'popupFooterBtns',
            data: {'btns': btns}
        });
    },

    _getShowAllData: function(filialsCount) {
        return {
            name: 'all',
            label: this.t('show_organization_in_building', filialsCount)
        };
    },

    _fillHouseObject: function(house) { // (Object) -> (Object)
        var self = this;

        return {
            header: this._fillHeader(house),
            tmpl: this._fillBody(house),
            footer: this._fillFooter(house),
            afterRender: function() {
                self._initShowMore();
                self._initPopupClose();
            }
        };
    }
});


================================================
FILE: src/DGGeoclicker/src/handler/House.js
================================================
/*global FirmCard */
DG.Geoclicker.Handler.House = DG.Geoclicker.Handler.Default.extend({

    _firmsOnPage: 20,
    _scrollThrottleInterval: 400,
    _scrollHeightReserve: 60,

    options: {
        'showBooklet': true,
        'showPhotos': true,
        'showRouteSearch': true
    },

    handle: function(results) { // (Object) -> Promise
        if (!results.building) {
            return false;
        }

        // initialization setup
        this.firmCard = null;
        this._page = 1;
        this._houseObject = null;
        this._firmList = null;
        this._firmListObject = null;
        this._firmCardObject = null;
        this._onScroll = false;
        this._isFirmlistOpen = false;

        this._id = results.building.id;
        this._totalPages = 1;
        this._api = this._controller.getCatalogApi();
        this._popup = this._view.getPopup();
        this._initedPopupClose = false;
        this._directionsUrl = this._getDirectionsUrl(results.building.name);
        this._firmListLoader = this._view.initLoader(true);

        this._houseObject = this._fillHouseObject(results.building);

        return Promise.resolve(this._houseObject);
    },

    _isRouteSearchAllowed: function() { //() -> Boolean
        var project = this._controller.getMap().projectDetector.getProject();
        return project.transport || project.roads;
    },

    _firmCardSetup: function() { //() -> Object
        var project = this._controller.getMap().projectDetector.getProject();
        return {
            render: this._view.renderTemplate,
            lang: this._map.getLang(),
            domain: project ? project.domain : 'ru',
            ajax: DG.bind(this._api.getFirmInfo, this._api),
            timezoneOffset: project ? project.timeOffset : 0,
            map: this._map,
            popup: this._popup,
            isMobile: DG.Browser.mobile,
            showEntrance: DG.Entrance,
            gotoUrl: this._directionsUrl,
            onFirmReady: DG.bind(this._onFirmReady, this),
            onToggle: DG.bind(this._popup.resize, this._popup),
            showBooklet: this.options.showBooklet,
            showPhotos: this.options.showPhotos,
            showRouteSearch: this.options.showRouteSearch && this._isRouteSearchAllowed(),
            t: DG.bind(this.t, this)
        };
    },

    // init single firm card in case of poi
    _fillFirmCardObject: function(firmId) {
        var options = this._firmCardSetup();

        this.firmCard = new FirmCard(firmId, options);
        this._initPopupClose();
        return this.firmCard.getContainer();
    },

    _firmListSetup: function() {
        var options = this._firmCardSetup();

        DG.extend(options, {
            backBtn: DG.bind(this._showHousePopup, this),
            onFirmClick: DG.bind(this._onFirmListClick, this),
            onShowLess: DG.bind(this._showHousePopup, this),
            pasteLoader: DG.bind(this._pasteLoader, this)
        });

        return {
            firmCard: options,
            firmlistItemTmpl: 'firmlistItem',
            onListReady: DG.bind(this._renderFirmList, this)
        };
    },

    _initShortFirmList: function(firms) { //(Object) -> DOMElement
        var options = this._firmListSetup();

        this._shortFirmList = new FirmCard.List(firms, options);

        return this._shortFirmList.renderList();
    },

    _initFirmList: function(res) { //(Object) -> Promise
        if (!res) { return false; }

        var results = res.result.items,
            options = this._firmListSetup();

        options.firmCard.backBtn = DG.bind(this._showListPopup, this);

        if (this._shortFirmList) {
            this._shortFirmList._toggleEventHandlers(true);
        }

        this._firmList = new FirmCard.List(results, options);

        this._firmListObject = this._fillFirmListObject(this._firmList.renderList());
        this._clearAndRenderPopup(this._firmListObject);
    },

    _fillFirmListObject: function(firmList) { //(DOMElement) -> Object
        var self = this;

        return {
            tmpl: firmList,
            header: this._header,
            footer: this._view.render({
                tmpl: 'popupFooterBtns',
                data: {
                    btns: [
                        {
                            name: 'back',
                            label: this.t('back_button'),
                            icon: true
                        }
                    ]
                }
            }),
            afterRender: function() {
                self._initPopupClose();

                if (self._totalPages > 1 && self._firmListLoader) {
                    // "this" here is self._firmListObject
                    this.tmpl.parentNode.appendChild(self._firmListLoader);
                }
            }
        };
    },

    _onFirmReady: function(firmContentObject) {
        var self = this;
        firmContentObject.afterRender = function() {
            var headerTitle = self._popup._popupStructure.header.firstChild;
            if (!DG.Browser.ielt9) {
                if (headerTitle.offsetHeight > 72) { //TODO: magic number
                    DG.DomUtil.addClass(headerTitle, 'dg-popup__header-teaser');
                    if (!DG.Browser.webkit) {
                        DG.Geoclicker.clampHelper(headerTitle, 3);
                    }
                }
            }
        };
        this._clearAndRenderPopup(firmContentObject);
    },

    _showHousePopup: function() {
        this._popup.off('scroll', this._onScroll);
        this._clearAndRenderPopup(this._houseObject);
        if (this._shortFirmList) {
            this._shortFirmList._toggleEventHandlers();
        }
    },

    _onFirmListClick: function() {
        this._popup.off('scroll', this._onScroll);
    },

    _pasteLoader: function() {
        var loaderWrapper  = DG.DomUtil.create('div', 'dg-map-geoclicker__preloader-wrapper'),
            loader = this._view.initLoader();

        loaderWrapper.insertBefore(loader, loaderWrapper.firstChild);
        loaderWrapper.style.height = this._popup._contentNode.offsetHeight - 1 + 'px'; // MAGIC
        loaderWrapper.style.width = this._popup._contentNode.offsetWidth + 'px';
        this._clearAndRenderPopup({tmpl: loaderWrapper});
    },

    _initPopupClose: function() {
        if (this._initedPopupClose) { return; }

        this._controller.getMap().once('popupclose', DG.bind(this._onPopupClose, this));
        this._initedPopupClose = true;
    },

    _showListPopup: function() {
        var firmList = this._firmListObject;

        this._pasteLoader();

        if (!firmList) {
            firmList = this._api.firmsInHouse(this._id).then(DG.bind(this._initFirmList, this));
        } else {
            this._clearAndRenderPopup(firmList);
            this._firmList._toggleEventHandlers();
        }

        if (!this._onScroll) {
            this._onScroll = DG.Util.throttle(this._handlePopupScroll, this._scrollThrottleInterval, this);
        }

        this._popup.on('scroll', this._onScroll);
    },

    _renderFirmList: function() {
        if (!this._isFirmlistOpen) {
            this._popup.resize();
            this._isFirmlistOpen = true;
        }
    },

    _onPopupClose: function() {
        this._initedPopupClose = false;
        if (this._firmList) {
            this._firmList.clearList();
            this._firmList = null;
            this._popup.off('scroll', this._onScroll);
        }
        this._firmId = null;
        if (this.firmCard) {
            this.firmCard._toggleEventHandlers(true);
            this.firmCard = null;
        }
        this._firmListLoader = null;
        this._page = 1;
        this._clearEventHandlers();
    },

    _initShowMore: function() {
        var link = this._popup.findElement('.dg-popup__button_name_all');

        if (link) {
            this._addEventHandler('dg-popup__button_name_all', DG.bind(this._showListPopup, this));
        }
    },

    _clearAndRenderPopup: function(popupObject) {
        this._clearEventHandlers();
        this._popup.clear('header', 'footer');
        this._view.renderPopup(popupObject);
    },

    _appendFirmList: function(res) { // (Object)
        this._firmList.addFirms(res.result.items);
        this._popup._updateScrollPosition();
    },

    _handlePopupScroll: function(e) {
        var scroller = e.originalEvent.target || e.target._scroller;

        DG.DomEvent.stop(e);

        if (this._totalPages <= 1) { return; }
        if (scroller && scroller.scrollHeight <= scroller.scrollTop + scroller.offsetHeight + this._scrollHeightReserve) {
            this._handlePaging();
        }
    },

    _handlePaging: function() {
        this._page++;

        if (this._totalPages && this._page <= this._totalPages) {
            this._api.firmsInHouse(this._id, {page: this._page}).then(DG.bind(this._appendFirmList, this));
        }

        if (this._page === this._totalPages) {
            var loader = this._firmListLoader;

            if (loader && loader.parentNode) {
                loader.parentNode.removeChild(loader);
            }

            this._popup.off('scroll', this._onScroll);
        }
    }
});


================================================
FILE: src/DGGeoclicker/src/handler/POI.js
================================================
DG.Geoclicker.Handler.Poi = DG.Geoclicker.Handler.House.extend({

    handle: function(results) { // (Object) -> Promise
        if (!results.poi) {
            return false;
        }

        // initialization setup
        this.firmCard = null;
        this._page = 1;
        this._houseObject = null;
        this._firmList = null;
        this._firmListObject = null;
        this._firmCardObject = null;
        this._onScroll = false;
        this._isFirmlistOpen = false;

        this._id = results.poi.reference.id;
        this._totalPages = 1;
        this._api = this._controller.getCatalogApi();
        this._popup = this._view.getPopup();
        this._initedPopupClose = false;
        this._directionsUrl = this._getDirectionsUrl(results.poi.reference.name);
        this._firmListLoader = this._view.initLoader(true);

        // If the POI refers to a building (e.g. galleries in Santiago),
        // show a building callout
        if (results.poi.reference.type === 'building') {
            var self = this;

            return self._api.geoGet(results.poi.reference.id)
                .then(function(result) {
                    self._houseObject = self._fillHouseObject(result.result.items[0]);
                    return Promise.resolve(self._houseObject);
                });
        }

        // Otherwise, show a firm callout
        if (results.poi.reference.type === 'branch') {
            this._fillFirmCardObject(results.poi.reference.id);
            return true;
        }

        return false;
    }

});


================================================
FILE: src/DGGeoclicker/src/handler/Sight.js
================================================
DG.Geoclicker.Handler.Sight = DG.Geoclicker.Handler.Default.extend({

    handle: function(results) { // (Object, String) -> Promise
        if (!results.attraction) {
            return false;
        }

        this._popup = this._view.getPopup();
        this._initedPopupClose = false;

        return Promise.resolve(this._fillSightObject(results));
    },

    _fillSightObject: function(results) { // (Object) -> Object
        var attraction = results.attraction,
            data = {},
            self = this,
            footer = {
                btns: [
                    {
                        name: 'goto',
                        label: this.t('go_to'),
                        icon: true
                    }
                ]
            };

        if (attraction.name) {
            data.buildingName = attraction.name;
            data.purpose = attraction.subtype_name;
        } else {
            data.buildingName = attraction.subtype_name;
        }

        data.description = attraction.description;

        data.drillDown = this._getDrilldown(attraction);

        if (this._checkDescFieldHeight(data.description)) {
            data.showMoreText = this.t('show_more_about_sight');
        }

        footer.btns[0].href = this._getDirectionsUrl(data.buildingName);

        return {
            tmpl: 'sight',
            data: data,
            header: this._view.render({
                tmpl: 'popupHeader',
                data: {'title': data.buildingName}
            }),
            footer: this._view.render({
                tmpl: 'popupFooterBtns',
                data: footer
            }),
            afterRender: function() {
                if (self._needShowMore) {
                    self._initShowMore();
                }
                self._initPopupClose();
            }
        };
    },

    _initPopupClose: function() {
        if (this._initedPopupClose) {
            return;
        }

        this._controller.getMap().once('popupclose', DG.bind(this._clearPopup, this));
        this._initedPopupClose = true;
    },

    _clearPopup: function() {
        this._initedPopupClose = false;
        this._clearEventHandlers();
    },

    _showMoreText: function() {
        this._desc.style.maxHeight = '100%';
        this._link.parentNode.removeChild(this._link);
        this._popup.resize();
    },

    _initShowMore: function() {
        this._link = this._popup.findElement('.dg-map-geoclicker__show-more-sights-link');
        this._desc = this._popup.findElement('.dg-map-geoclicker__sight-description');

        if (this._link && this._desc) {
            this._addEventHandler('dg-map-geoclicker__show-more-sights-link', DG.bind(this._showMoreText, this));
        }
    },

    _checkDescFieldHeight: function(desc) {
        var el = DG.DomUtil.create('div', ''),
            height;

        el.style.visibility = 'hidden';
        el.innerHTML = desc;

        this._popup._contentNode.appendChild(el);
        height = el.offsetHeight;
        this._popup._contentNode.removeChild(el);
        this._needShowMore = (height > 40);

        return this._needShowMore;
    }
});


================================================
FILE: src/DGGeoclicker/src/provider/CatalogApi.js
================================================
DG.Geoclicker.Provider.CatalogApi = DG.Class.extend({
    initialize: function(map) { // (Object)
        this._map = map;

        var apiUrl = DG.config.protocol +
            DG.config.webApiServer + '/' +
            DG.config.catalogVersion + '/';

        this._urlGeoSearch = apiUrl + 'items/geocode';
        this._urlGeoGet = apiUrl + 'items/byid';
        this._urlDetails = apiUrl + 'items/byid';
        this._urlFirmsInHouse = apiUrl + 'items';

        this._key = this._map.options.key || DG.config.geoclickerCatalogApiKey;
        this._geoFields = DG.config.geoAdditionalFields;
        this._firmInfoFields = DG.config.firmInfoFields;
    },

    getLocations: function(options) { // (Object)
        // Callback will receive array of found results or void if errors occurred or nothing was found.
        var zoom = options.zoom,
            latlng = options.latlng,
            hasCatalogKey = options.hasCatalogKey,
            beforeRequest = options.beforeRequest || function() {},
            types = this.getTypesByZoom(zoom),
            q = latlng.lng + ',' + latlng.lat;

        if (!types) {
            return Promise.reject('no type');
        }

        if (hasCatalogKey) {
            beforeRequest();
        }

        return this.geoSearch(q, types, zoom).then(DG.bind(function(result) {
            return this._filterResponse(result, types);
        }, this));
    },

    firmsInHouse: function(houseId, parameters) { // (String, Function, Number)
        parameters = parameters || {};

        /* eslint-disable camelcase */
        var params = {
            building_id: houseId,
            page: parameters.page || 1
        };
        /* eslint-enable camelcase */

        return this._performRequest(params, this._urlFirmsInHouse);
    },

    getFirmInfo: function(firmId) {
        return this._performRequest({
            type: 'filial',
            id: firmId,
            fields: this._firmInfoFields
        }, this._urlDetails);
    },

    geoSearch: function(q, types, zoomlevel) { // (String, String, Number)
        /* eslint-disable camelcase */
        var params = {
            point: q,
            type: types,
            zoom_level: zoomlevel,
            fields: this._geoFields
        };
        /* eslint-enable camelcase */

        return this._performRequest(params, this._urlGeoSearch);
    },

    geoGet: function(id) {
        var params = {
            id: id,
            fields: this._geoFields
        };

        return this._performRequest(params, this._urlGeoGet);
    },

    cancelLastRequest: function() {
        if (this._lastRequest) {
            this._lastRequest.abort();
        }
    },

    getTypesByZoom: function(zoom) { // (Number) -> String|Null
        var types = {
                'adm_div.settlement':   8,
                'adm_div.city':         8,
                'adm_div.division':     11,
                'adm_div.district':     12,
                'street':               14,
                'building':             14,
                'adm_div.place':        15,
                'attraction':           17
            },
            selectedTypes = [];

        Object.keys(types).forEach(function(type) {
            if (zoom >= types[type]) {
                selectedTypes.push(type);
            }
        });

        if (selectedTypes.length) {
            return selectedTypes.join(',');
        } else {
            return null;
        }
    },

    _performRequest: function(params, url) { // (Object, String, Function, Function)
        var data = DG.extend({key: this._key}, params);
        var type = 'get';

        this.cancelLastRequest();

        if (!DG.ajax.corsSupport) {
            type = data.format = 'jsonp';
        }

        this._lastRequest = DG.ajax(url, {
            type: type,
            data: data,
            timeout: this._timeoutMs,
            withCredentials: true
        });

        return this._lastRequest;
    },

    _filterResponse: function(response, allowedTypes) { // (Object, Array) -> Boolean|Object
        var result = {}, i, item, found, data, type;

        if (this._isNotFound(response)) {
            if (response && response.meta && response.meta.code === 403) {
                console.error('The catalog service is unavailable. Please contact api@2gis.com to get the RasterJS API key');
                return response
            }

            return false;
        }

        data = response.result.items;

        for (i = data.length - 1; i >= 0; i--) {
            item = data[i];

            type = item.type;
            if (item.subtype) {
                type += '.' + item.subtype;
            }

            if (allowedTypes && allowedTypes.indexOf(type) === -1) {
                continue;
            }

            result[type] = item;
            found = true;
        }

        if (found) {
            return result;
        } else {
            return false;
        }
    },

    _isNotFound: function(response) { // (Object) -> Boolean
        return !response ||
               !!response.meta && !!response.meta.error ||
               !response.result ||
               !response.result.items ||
               !response.result.items.length;
    }

});


================================================
FILE: src/DGGeoclicker/src/provider/Provider.js
================================================
DG.Geoclicker.Provider = {};


================================================
FILE: src/DGGeoclicker/templates/cityarea.dust
================================================
<div class="dg-map-geoclicker__purpose dg-map-geoclicker__purpose_type_{type}">{purpose}</div>

{#drilldown}
<div class="dg-map-geoclicker__drilldown">{drilldown}</div>
{/drilldown}


================================================
FILE: src/DGGeoclicker/templates/firmCardAddr.dust
================================================
<address class="dg-firm-card__address dg-firm-card__icon">
    {address}
    {#comment}
        <span class="dg-firm-card__comment">&mdash; {.}</span>
    {/comment}
</address>


================================================
FILE: src/DGGeoclicker/templates/firmCardContacts.dust
================================================
{#groups}
    {#contacts}
        {@select key=type type="string"}
            {@eq value="phone" type="string"}
                <div class="dg-firm-card__phone dg-firm-card__icon">
                    <span class="dg-firm-card__phone-num">
                        {text}
                        {#comment}
                            <span class="dg-firm-card__comment" title="{.}">&mdash;&nbsp;&nbsp;{.}</span>
                        {/comment}
                    </span>
                </div>
            {/eq}
            {@eq value="fax" type="string"}
                <div class="dg-firm-card__phone dg-firm-card__icon">
                    <span class="dg-firm-card__phone-num">
                        {text}
                        {#comment}
                            <span class="dg-firm-card__comment" title="{.}">&mdash;&nbsp;&nbsp;{.}</span>
                        {/comment}
                    </span>
                </div>
            {/eq}
            {@eq value="website" type="string"}
                <div class="dg-firm-card__link dg-firm-card__site dg-firm-card__icon">
                    <a href="{url}" target="_blank" class="dg-link_scheme_dark dg-firm-card__sitelink">{text}</a>
                </div>
            {/eq}
            {@eq value="email" type="string"}
                <div class="dg-firm-card__link dg-firm-card__email dg-firm-card__icon">
                    <a href="mailto:{value}">{value}</a>
                </div>
            {/eq}
        {/select}
    {/contacts}
{/groups}


================================================
FILE: src/DGGeoclicker/templates/firmCardHeader.dust
================================================
<div class="dg-popup__header-title dg-popup__header-title_for_firmcard" title="{firmName}">{firmName}</div>

{?links}
    <div class="dg-popup__header-links">
        {#links}
            {@eq key="{name}" value="flamp_stars" type="string"}
                <div class="dg-popup__rating">
                    <div class="dg-popup__rating-stars" style="width: {width}%"></div>
                </div>
            {:else}
                <a class="dg-popup__header-link dg-popup__link dg-popup__link_type_{name}"
                    {?href}
                        href={href} target="_blank"
                    {:else}
                        href="javascript:void(0)"
                    {/href}
                    >{label}</a>
            {/eq}
        {/links}
    </div>
{/links}


================================================
FILE: src/DGGeoclicker/templates/firmCardRubric.dust
================================================
{#rubrics}
    <section class="dg-firm-card__rubrics">
        {?primary}
            <ul class="dg-firm-card__rubrics-list dg-firm-card__rubrics-list_type_primary">
                {#primary}
                    <li class="dg-firm-card__rubrics-list-item">
                        {name}
                    </li>
                {/primary}
            </ul>
        {/primary}
        {?additional}
            <ul class="dg-firm-card__rubrics-list dg-firm-card__rubrics-list_type_additional">
                {#additional}
                    <li class="dg-firm-card__rubrics-list-item">
                        {name}
                    </li>
                {/additional}
            </ul>
        {/additional}
    </section>
{/rubrics}


================================================
FILE: src/DGGeoclicker/templates/firmCardSchedule.dust
================================================
<div class="dg-firm-card__schedule dg-schedule dg-schedule_open_{?forecast.open}true{:else}false{/forecast.open} dg-schedule_works-everyday_{?schedule.everyday}true{:else}false{/schedule.everyday}">
    {?schedule}
        {?forecast.today}
            <div class="dg-schedule__today">
                <div class="dg-schedule__today-inner">
                    {forecast.today.text}&nbsp;
                    {?forecast.today.from}
                        {forecast.today.from}&ndash;{forecast.today.to}
                    {/forecast.today.from}

                    {?schedule.lunch}
                        ,&nbsp;{forecast.today.lunchStr}&nbsp;
                        {#schedule.lunch}
                            {from}&ndash;{to}
                        {/schedule.lunch}
                    {/schedule.lunch}
                </div>
            </div>
        {/forecast.today}

        {#forecast.now}
            <div class="dg-schedule__now">
                {!Вывод строки прогноза, например "откроется завтра" или "закроется через 15 минут" !}
                <span class="dg-schedule__now-text">{.}{#schedule.comment},{~s}{.}{/schedule.comment}</span>
            </div>
        {/forecast.now}

        {^schedule.everyday}
        {!Если ежедневно одно и то же расписание - попап не нужен !}
            {?schedule.week}
                {!Упрощённое расписание !}
                {?schedule.week.evently}
                    <div class="dg-schedule__table">
                        {#schedule.week.evently}
                            <div class="dg-schedule__string">
                                {?alltime}
                                    {alltimeStr}
                                {/alltime}
                                {?everyday}
                                    {forecast.today.text}
                                {:else}
                                    {dayList}
                                {/everyday}
                                {?holiday}
                                    &nbsp;&mdash;<span class="schedule__string-time">&nbsp;{holidayStr}</span>
                                {:else}
                                    <span class="schedule__string-time">&nbsp;{from}&ndash;{to}</span>
                                    {#lunch}
                                        <p>{lunchStr}&mdash;
                                            <span class="schedule__string-time">
                                                {from}&ndash;{to}
                                            </span>
                                        </p>
                                    {/lunch}
                                {/holiday}
                            </div>
                        {/schedule.week.evently}
                    </div>
                {/schedule.week.evently}

                {! Неупрощаемое расписание - таблица !}
                {?schedule.week.table}
                    <div>
                        <div class="dg-schedule__table">
                            <div class="dg-schedule__tc dg-schedule__tc_pre">
                                <div class="dg-schedule__day-name">&nbsp;</div>
                                <div class="dg-schedule__table-clock dg-schedule__td"></div>
                                {?schedule.week.hasLunch}
                                    <div class="dg-schedule__table-lunch dg-schedule__td"></div>
                                {/schedule.week.hasLunch}
                            </div>
                            {#schedule.week.table}
                                {@if cond="({$idx} == {$len} - 2)"}
                                    <span class="dg-schedule__table-cell-group">
                                {/if}

                                <div class="dg-schedule__tc{?active} dg-schedule__tc_active_true{/active}">
                                    <div class="dg-schedule__day-name">{key}</div>
                                    <div class="dg-schedule__td">
                                        {?from}
                                            {from} {to}
                                        {:else}
                                            &ndash;
                                        {/from}
                                    </div>
                                    {#lunch}
                                        <div class="dg-schedule__td">
                                            {?from}
                                                {from} {to}
                                            {:else}
                                                &ndash;
                                            {/from}
                                        </div>
                                    {/lunch}
                                </div> {! dg-schedule__tc !}

                                {@if cond="({$idx} == {$len})"}
                                    </span>
                                {/if}
                            {/schedule.week.table}
                        </div>  {! dg-schedule__table !}
                    </div>
                {/schedule.week.table}
            {/schedule.week}
        {/schedule.everyday}
    {/schedule}
</div>


================================================
FILE: src/DGGeoclicker/templates/firmlistItem.dust
================================================
<a id="{firm.id}" class="dg-popup__link" href="#">{firm.name}</a>


================================================
FILE: src/DGGeoclicker/templates/frimCardPayments.dust
================================================
{?payments}
    <section class="dg-firm-card__aa">
        <ul class="dg-firm-card__aa-list">
            {#payments}
                <li class="dg-firm-card__aa-list-item">{.}</li>
            {/payments}
        </ul>
    </section>
{/payments}


================================================
FILE: src/DGGeoclicker/templates/house.dust
================================================
{#address}
<address class="dg-map-geoclicker__address">
	{#address.header}
	    <div class="dg-map-geoclicker__address-header">{.}</div>
	{/address.header}

	{#address.drilldown}
	    <div class="dg-map-geoclicker__address-drilldown">{.}</div>
	{/address.drilldown}
</address>
{/address}

{#purpose}
	<div class="dg-map-geoclicker__purpose">{.}</div>
{/purpose}

{#attractions}
    <div class="dg-map-geoclicker__purpose dg-map-geoclicker__purpose_type_sight">{.}</div>
{/attractions}


================================================
FILE: src/DGGeoclicker/templates/loader.dust
================================================
<div class="dg-preloader dg-preloader_scheme_regular dg-preloader_animation_{?anim}true{:else}false{/anim}{?small} dg-preloader_size_small{/small}"></div>


================================================
FILE: src/DGGeoclicker/templates/popupFooter.dust
================================================
<div class="dg-popup__footer-title">
    <a class="dg-popup__show-less-house-link" href="javascript:void(0)">{hideFirmsText}</a>
</div>


================================================
FILE: src/DGGeoclicker/templates/popupFooterBtns.dust
================================================
{?btns}
    <footer class="dg-popup__footer-buttons">
        {#btns}
            <div class="dg-popup__footer-button-wrapper">
                <a class="dg-popup__button_name_{name} dg-popup__footer-button{?icon} dg-popup__footer-icon-button{/icon}"
                    {?href}
                        href={href} target="_blank"
                    {:else}
                        href="javascript:void(0)"
                    {/href}
                    >{label}</a>
            </div>
        {/btns}
    </footer>
{/btns}


================================================
FILE: src/DGGeoclicker/templates/popupHeader.dust
================================================
{#title}
    <div class="dg-popup__header-title">{.}</div>
{/title}


================================================
FILE: src/DGGeoclicker/templates/sight.dust
================================================
{#purpose}
	<div class="dg-map-geoclicker__purpose dg-map-geoclicker__purpose_type_sight">{.}</div>
{/purpose}

{#address}
<address class="dg-map-geoclicker__address">
	{#address.header}
	    <div class="dg-map-geoclicker__address-header">{.}</div>
	{/address.header}

	{#address.drilldown}
	    <div class="dg-map-geoclicker__address-drilldown">{.}</div>
	{/address.drilldown}
</address>
{/address}

{#description}
    <div class="dg-map-geoclicker__sight-description">{.}</div>
    {#showMoreText}
        <a class="dg-map-geoclicker__show-more-sights-link" href="javascript:void(0)">{.}</a>
    {/showMoreText}
{/description}


================================================
FILE: src/DGGeoclicker/test/CatalogApiSpec.js
================================================
describe('DG.Geoclicker.Provider.CatalogApi', function () {

    var catalogApi,
        spy,
        map,
        mapContainer = document.createElement("div");

    after(function() {
        mapContainer = null;
    });

    beforeEach(function () {
        map = new DG.Map(mapContainer, {
            center: new DG.LatLng(54.98117239821992, 82.88922250270844),
            zoom: 17,
            key: window.__karma__.config.secretKey,
        });
        catalogApi = new DG.Geoclicker.Provider.CatalogApi(map);
        spy =  sinon.spy(catalogApi, "getTypesByZoom");
    });

    afterEach(function () {
        spy = null;
        catalogApi = null;
        map.remove();
        map = null;
    });

    describe("#getTypesByZoom", function() {

        it('should send correct types to the server corresponded to zoomlevel', function () {
            var zoomToTypesMap = {
                    0:  null,
                    1:  null,
                    2:  null,
                    3:  null,
                    4:  null,
                    5:  null,
                    6:  null,
                    7:  null,
                    8:  'adm_div.settlement,adm_div.city',
                    9:  'adm_div.settlement,adm_div.city',
                    10: 'adm_div.settlement,adm_div.city',
                    11: 'adm_div.settlement,adm_div.city,adm_div.division',
                    12: 'adm_div.settlement,adm_div.city,adm_div.division,adm_div.district',
                    13: 'adm_div.settlement,adm_div.city,adm_div.division,adm_div.district',
                    14: 'adm_div.settlement,adm_div.city,adm_div.division,adm_div.district,street,building',
                    15: 'adm_div.settlement,adm_div.city,adm_div.division,adm_div.district,street,building,adm_div.place',
                    16: 'adm_div.settlement,adm_div.city,adm_div.division,adm_div.district,street,building,adm_div.place',
                    17: 'adm_div.settlement,adm_div.city,adm_div.division,adm_div.district,street,building,adm_div.place,attraction',
                    18: 'adm_div.settlement,adm_div.city,adm_div.division,adm_div.district,street,building,adm_div.place,attraction',
                    19: 'adm_div.settlement,adm_div.city,adm_div.division,adm_div.district,street,building,adm_div.place,attraction'
                },
                zoom;

            for (zoom in zoomToTypesMap) {
                catalogApi.getTypesByZoom(zoom);
                expect(spy.returnValues.pop()).to.be.equal(zoomToTypesMap[zoom]);
            }

        });

    });

});


================================================
FILE: src/DGGeoclicker/test/ControllerSpec.js
================================================
/*global describe:false, it:false, expect:false, beforeEach:false, afterEach:false, sinon:false */

describe('DG.Geoclicker.Controller', function () {
    var map,
        mapContainer = document.createElement('div'),
        spy,
        initZoom = 17,
        controller;

    after(function() {
        mapContainer = initZoom = null;
    });

    beforeEach(function () {
        map = new DG.Map(mapContainer, {
            center: new DG.LatLng(54.98117239821992, 82.88922250270844),
            zoom: initZoom,
            key: window.__karma__.config.secretKey,
        });
        controller = map.geoclicker.getController();
    });

    afterEach(function () {
        map.remove();
        map = null;
        spy = null;
        controller = null;
    });

    describe('#findHandler', function () {

        it('should return null if handler name was not found (as a result - the default handler will be called)', function () {

            spy = sinon.spy(controller, 'findHandler');

            controller.findHandler({'somedummyhandler': 1});

            expect(spy.returnValues.pop()).to.be.equal(null);

        });


        it('should return correct handler name if handler was found', function () {

            spy = sinon.spy(controller, 'findHandler');

            controller.findHandler({'building': 2});

            expect(spy.returnValues.pop()).to.be.equal('building');
        });

    });

    describe('#handleResponse', function () {
        var defaultSpy,
            houseSpy,
            districtSpy,
            citySpy,
            defaultHandler,
            cityHandler,
            districtHandler,
            houseHandler;

        beforeEach(function () {

            defaultSpy = sinon.stub().returns(Promise.resolve({}));
            houseSpy = sinon.stub().returns(Promise.resolve({}));
            citySpy = sinon.stub().returns(Promise.resolve({}));
            districtSpy = sinon.stub().returns(false);

            addClickEventStub = sinon.stub();

            defaultHandler = DG.Class.extend({
                handle: defaultSpy,
                addClickEvent: addClickEventStub
            });
            houseHandler = DG.Class.extend({
                handle: houseSpy,
                addClickEvent: addClickEventStub
            });
            cityHandler = DG.Class.extend({
                handle: citySpy,
                addClickEvent: addClickEventStub
            });
            districtHandler = DG.Class.extend({
                handle: districtSpy,
                addClickEvent: addClickEventStub
            });

            DG.Geoclicker.Controller.mergeOptions({
                handlersSequence: {
                    default: defaultHandler,
                    house: houseHandler,
                    district: districtHandler,
                    city: cityHandler
                }
            });

        });

        afterEach(function () {

            defaultSpy = null;
            districtSpy = null;
            houseSpy = null;
            citySpy = null;
            defaultHandler = null;
            houseHandler = null;
            districtHandler = null;
            cityHandler = null;

        });


        it('should call only default handler if no result was received from WebApi', function () {

            controller.handleResponse(undefined);

            expect(defaultSpy.called).to.be.ok();
            expect(houseSpy.called).to.not.be.ok();

        });

        it('should call correct handler according to response of WebApi', function () {

            controller.handleResponse({
                'house' : 2
            });

            expect(defaultSpy.called).to.not.be.ok();
            expect(houseSpy.called).to.be.ok();

        });

        it('should call next handler if previous returned false', function () {

            controller.handleResponse({
                'district': 1,
                'city': 3
            });

            expect(districtSpy.called).to.be.ok();
            expect(citySpy.called).to.be.ok();
            expect(defaultSpy.called).to.not.be.ok();
            expect(houseSpy.called).to.not.be.ok();

        });

    });

});



================================================
FILE: src/DGGeoclicker/test/GeoclickerSpec.js
================================================
describe('DG.Geoclicker', function () {
    var map,
        mapContainer = document.createElement("div");

    after(function() {
        mapContainer = null;
    });

    afterEach(function () {
        DG.Map.mergeOptions({
            geoclicker: true
        });
        map && map.remove();
        map = null;
    });

    describe("#enabled", function() {

        it('should be inactive, if DG.Map.options.geoclicker was set to false', function () {

            DG.Map.mergeOptions({
                geoclicker: false
            });

            map = new DG.Map(mapContainer, {
                center: new DG.LatLng(54.98117239821992, 82.88922250270844),
                zoom: 17,
                key: window.__karma__.config.secretKey,
            });

            expect(map.geoclicker.enabled()).to.be.equal(false);


        });

        it('should be active by default', function () {
            map = new DG.Map(mapContainer, {
                center: new DG.LatLng(54.98117239821992, 82.88922250270844),
                zoom: 17,
                key: window.__karma__.config.secretKey,
            });

            expect(map.geoclicker.enabled()).to.be.equal(true);
        });

    });

});

describe('DG.Geoclicker advance tests', function () {
    var map, mapContainer, spy;

    before(function() {
        mapContainer = document.createElement('div');
        document.body.appendChild(mapContainer);

        map = new DG.Map(mapContainer, {
            center: [55.017493, 82.819576],
            zoom: 15,
            geoclicker: true,
            key: window.__karma__.config.secretKey,
        });
    });

    after(function() {
        document.body.removeChild(mapContainer);
        map = mapContainer = spy = null;
    });

    describe('check init', function() {
        it('should map has geocliker field', function() {
            expect(map.geoclicker).to.be.ok();
        });

        it('#getController should return DG.Geoclicker.Controller', function() {
            expect(map.geoclicker.getController()).to.be.a(DG.Geoclicker.Controller);
        });
    });

    describe('clicks', function() {
        describe('click to Sun City', function() {
            var xhr, requests, clock, latlng, responseData;

            before(function() {
                responseData = '{"response":{"code":200,"method":"http:\/\/catalog.api.2gis.ru\/doc\/2.0\/geo\/geo-search\/search-by-point"},"result":{"total":{"total_count":4,"geo_count":4},"data":[{"id":"141373143572328","name":"Новосибирск, Карла Маркса площадь, 7","type":"geo","geo_type":"house","short_name":"7","synonym":"Многофункциональный комплекс Сан Сити;Многофункциональный комплекс СанСити","dist":0,"geometry":{"centroid":"POINT(82.8977660986355 54.9800753777939)","selection":"POINT(82.8977660986355 54.9800753777939)"},"adm_divs":[{"id":"141360258613345","type":"city","name":"г. Новосибирск"},{"id":"141347373711435","type":"district","name":"Ленинский район"}],"attributes":{"city":"Новосибирск","district":"Ленинский район","micro_district":null,"addresses":[{"street":"Карла Маркса площадь","number":"7"}],"postal_code":"630048","building_description":"Торгово-развлекательный комплекс","building_name":"Сан Сити, многофункциональный комплекс","floors_count":23,"filials_count":211,"filials":{"popular":[{"id":"141265770417218","name":"Сан Сити, многофункциональный комплекс","rubric_name":"Торгово-развлекательные центры \/ Моллы"},{"id":"141265771060872","name":"Здравица, центры семейной медицины","rubric_name":"Диагностические центры"},{"id":"141265770538610","name":"Синема Парк, кинотеатр","rubric_name":"Кинотеатры"}],"servicing":{"total_count":15,"items":[{"id":"141265769370483","name":"Orange Business Services, телекоммуникационная компания, ООО Эквант","rubric_name":"Интернет-провайдеры"},{"id":"141265769407070","name":"Энфорта, ООО Престиж-Интернет","rubric_name":"Интернет-провайдеры"},{"id":"141265769349880","name":"Билайн Бизнес, ОАО ВымпелКом","rubric_name":"Интернет-провайдеры"}]}},"sight":null}},{"id":"141347373711435","name":"Новосибирск, Ленинский","type":"geo","geo_type":"district","short_name":"Ленинский","synonym":null,"dist":0,"geometry":{"centroid":"POINT(82.8944577831071 54.9837576912103)","selection":"POLYGON((82.9310537104777 55.0051498598707,82.9206144783925 55.009243785233,82.9185642534195 55.0100450677819,82.9156961123804 55.0111660637911,82.8691163089421 55.0330232906245,82.8248493978659 55.045721473722,82.8237138375152 55.0447540975008,82.8046557194365 55.0367373985273,82.7964982081729 55.0309059519357,82.7946678907815 55.0316017730696,82.7936154245947 55.030602906857,82.7931388683365 55.0299274056716,82.7914912682739 55.0283465751258,82.7914463525096 55.0282768591815,82.7914344049164 55.0282265544699,82.7914451846998 55.0281831492278,82.791486866529 55.0281458711414,82.792501783137 55.0275815981919,82.7928437717656 55.0274466946402,82.7924745641838 55.0272474793664,82.7923847326554 55.02721200257,82.7922147714037 55.0271631897421,82.7921129024505 55.0271160760385,82.7920469661086 55.0270632983267,82.7871355171242 55.0227447647132,82.7812429281865 55.0229128989067,82.778531632996 55.0226180842731,82.7777741735484 55.0227926559948,82.7775053077839 55.0224076702671,82.7772894426211 55.0208850453531,82.77970618023 55.0178489439407,82.7791320669319 55.0167147437669,82.7784043417202 55.0161830152288,82.7786256866062 55.0160915432002,82.778734113261 55.0159958475776,82.7788214295066 55.0158886146441,82.778868591059 55.0157937941215,82.7788720944886 55.0156898569738,82.7784150316721 55.0147953064994,82.7780848109736 55.0142931689784,82.7770908251118 55.0132987131325,82.7644834192568 55.0027389214354,82.7584720730385 54.9974510523445,82.7581874867565 54.9972321585879,82.7528471820555 54.9924731399271,82.7523955091306 54.9917477794525,82.7523551747744 54.9916841841683,82.7520408542565 54.9911738721697,82.7507523108129 54.9885144963879,82.7561791232758 54.9867598303463,82.762198105174 54.9829297491167,82.7673041292489 54.9796888477779,82.7674439969387 54.9796000762886,82.7734462701726 54.9758857260116,82.7765117710796 54.9738434293431,82.7863153552698 54.9680278418825,82.7865251118887 54.9678583946562,82.7906529604507 54.9653724505173,82.7938443153291 54.96361527732,82.7980247153353 54.9617050578248,82.7998279934366 54.9605926337788,82.7998960857351 54.9600686713315,82.7999811561925 54.9599004283719,82.8001579446404 54.9597479672519,82.80067043351 54.9594063202058,82.8007465208146 54.9593555680417,82.8012886540886 54.9589608955698,82.8013412055327 54.9589374275995,82.8014119029455 54.9589218510489,82.8014836783368 54.9589207679111,82.8018773200942 54.9590210869828,82.8019698465685 54.9590262963467,82.8020673137768 54.9590137629253,82.8021444790597 54.9589896244731,82.8030032684714 54.9585287732502,82.80393652822 54.958985807708,82.8061128766589 54.9575149335337,82.8102042536204 54.9547854442511,82.8168374136783 54.9502621595006,82.8170768147016 54.9501781207567,82.8176340396723 54.9499269320825,82.8191845318527 54.9489869597144,82.8198879127201 54.9486931493524,82.8205108943697 54.948537653412,82.8220605780663 54.9477813691247,82.8221968524949 54.9477395277544,82.8223289946732 54.947725339857,82.8224671555639 54.9477365353983,82.8225129696434 54.9477101716992,82.8231887722316 54.9473512934815,82.8232291065879 54.9473299340385,82.8238393321604 54.9469931343658,82.827709543899 54.9448574244386,82.8298356765134 54.9437720353976,82.8299706034691 54.943891896066,82.8300923251901 54.9440048939582,82.8317846613539 54.9432486791837,82.8318049632793 54.9433092553181,82.8322271714628 54.9437051650631,82.8326022180939 54.9440201151112,82.8329237251341 54.944128520512,82.8331461479985 54.9442195374814,82.8333151211034 54.9443300062135,82.8335338608751 54.9445768957666,82.8343897756778 54.9457509548046,82.8346470531752 54.9459487691551,82.8350521933683 54.946154063718,82.8355731264016 54.9463087949664,82.8363066008311 54.9464082684254,82.8368154964395 54.9464135310186,82.8369580590751 54.9464472219173,82.8375911018558 54.9466978648069,82.8381712338663 54.9467834586346,82.8383653597992 54.9468293252943,82.8386367408465 54.9472015707706,82.8387289079947 54.9472432063289,82.8393848578152 54.9473763675956,82.8395112507756 54.947426515777,82.8397634977074 54.9476243734748,82.8398328476473 54.9477794602098,82.8398722836883 54.9483968604508,82.8399082162997 54.9485686081926,82.8399394776716 54.948626648342,82.840078447046 54.948705737584,82.8408753425346 54.9489107085221,82.840990506554 54.9489953690048,82.8410122457839 54.9490975185271,82.8409527773121 54.9492176728602,82.8407696108256 54.9493653244514,82.8398955500542 54.9500127769816,82.8397357397651 54.9502265630007,82.8396876798974 54.9504160495135,82.8397141801983 54.9505032862655,82.8399031857341 54.9506827117043,82.8401048575154 54.9507705153505,82.8404631056507 54.9508171512867,82.8408457879617 54.9507757257841,82.8423659170855 54.9503603850411,82.8426096300221 54.9503619842995,82.8428314240657 54.9504138311903,82.8429727290599 54.9505081356122,82.8430076735245 54.950606308963,82.8429969835726 54.9528605672577,82.8430748675077 54.9530307999456,82.8432328811662 54.9531494465441,82.8434367987357 54.9532299712751,82.8436772777373 54.9532882626197,82.8450879920594 54.9534281615017,82.8453732071621 54.9534800044372,82.8455985046354 54.9535876105555,82.848091688875 54.9553223712495,82.8481352571662 54.9554146008545,82.8481128891157 54.9555114210789,82.8477452086699 54.9560011926939,82.847721762641 54.9560963608933,82.8477695530141 54.9562284096205,82.8478879509685 54.9563103724598,82.8481749627018 54.9564058494143,82.8485412956747 54.9564910615019,82.8489227203443 54.956526239805,82.8492119778658 54.9565158204281,82.8494889284679 54.9564656835867,82.8496981460976 54.9563716510498,82.8498304679389 54.9562708611308,82.8503472687219 54.9554278059708,82.8504686311167 54.9553674544274,82.8506445212494 54.9553436232802,82.8509335092763 54.9553895833371,82.8512526806967 54.9555135875384,82.8514481541025 54.9556487846945,82.8519658532008 54.9561056455836,82.8520122062694 54.9561861128098,82.8519931619854 54.9562714285261,82.851648658074 54.9567676384734,82.8516228764253 54.9569946963247,82.8515254990485 54.957228406735,82.8514802239582 54.9573838690536,82.8514470761242 54.9574524187701,82.8508701780487 54.9578200268799,82.8502836679997 54.958550229899,82.85012969676 54.9587687672775,82.8500263006708 54.9589971032686,82.8500005190222 54.9591632869035,82.8500554959176 54.9593398884984,82.8501821583726 54.9594989530555,82.8503802368928 54.9596280507075,82.8507004862916 54.9597217145853,82.8510414867734 54.959758849983,82.8532998513977 54.9596720975142,82.8535119436363 54.9596808140311,82.853637707776 54.9597102129204,82.8537347258267 54.9597537438678,82.8544591272719 54.9603126275291,82.8545833642756 54.9603704444151,82.855638974566 54.9605741696213,82.8557643793797 54.9606418886827,82.8560875033874 54.9611314946159,82.8562646511614 54.9612985977718,82.8565408831113 54.9614246983044,82.8568448730034 54.9614955619882,82.8571633257716 54.9615093840022,82.8574817785398 54.9614803990271,82.8591707011055 54.9610174102102,82.8593218875678 54.9610180806891,82.8607156237312 54.9615118595863,82.8608834290262 54.9616153698098,82.8619199950326 54.9625366867253,82.862207545755 54.9626882089464,82.8625368681382 54.9627966671491,82.862899787513 54.9628704680698,82.8632497711477 54.9629007929371,82.8652986486477 54.962940865048,82.8702157570184 54.9623793876953,82.8709533636981 54.9623302896424,82.8715441856605 54.9623664943048,82.87207841376 54.9624485993444,82.8726873816911 54.9625937268116,82.8732554762768 54.9628373582395,82.8738133300682 54.9631528804037,82.8749716177955 54.9638431216236,82.8739437654475 54.9655452086781,82.8736730132208 54.9661334575357,82.8738308472163 54.9661470201105,82.8739532875895 54.9661764142683,82.8740322495029 54.9662274156595,82.8740692600926 54.9662958471513,82.8740754584681 54.9663882578431,82.8728248239295 54.9747142486374,82.8772078838638 54.9749209945533,82.8784832220727 54.9749663650857,82.8798803718341 54.9750269965353,82.8813494766497 54.9757819947757,82.8855894349592 54.9759773412987,82.8851920202776 54.9790051682111,82.8881460402579 54.9791312647148,82.8882973165517 54.9780027745582,82.8926514507338 54.9781966667865,82.8924826572919 54.9794655267929,82.8929213944767 54.9797629269716,82.892677322214 54.9798789170838,82.8934536462826 54.9804188079829,82.8968202624728 54.9787755024658,82.8971547950847 54.9789309845146,82.9097629195919 54.9864168667424,82.9098286762706 54.9864395970629,82.9099134772335 54.9864573792775,82.909988037402 54.986468100145,82.9100563093637 54.9864734605777,82.9101295220593 54.9864750068563,82.9102907696528 54.9864741306318,82.9137278137614 54.986363159222,82.9137446122572 54.9867846221614,82.9137386833763 54.9872803521648,82.9136200159273 54.9921287821521,82.913576447636 54.9928289353984,82.9136473247119 54.9931596821832,82.913699696493 54.9932925882334,82.9137845872873 54.9934113220757,82.91408390594 54.9937025895449,82.9310537104777 55.0051498598707))"},"adm_divs":[{"id":"141360258613345","type":"city","name":"г. Новосибирск"}],"attributes":{"area":709396967836.5,"houses_count":null,"city":"Новосибирск"}},{"id":"141424683123064","name":"Новосибирск, Левый берег","type":"geo","geo_type":"place","short_name":"Левый берег","synonym":null,"dist":0,"geometry":{"centroid":"POINT(82.8985053222828 54.9843972701992)","selection":"POLYGON((82.9814220687952 54.8522393858022,82.981498695089 54.8522524179416,82.9815474736089 54.8522516422191,82.9815925690362 54.8522409372476,82.9816205066415 54.8522388169389,82.9816987499027 54.8522293014058,82.981768998158 54.852210166903,82.9818368209619 54.8521807411229,82.9841541150688 54.8508467843605,82.984300181134 54.8508033940825,82.9844185790885 54.8507979638299,82.9845175734328 54.8508052041665,82.9872093751816 54.8495045085516,82.9874732103806 54.849684798328,83.0053009060146 54.8607247961862,83.0122303304533 54.8681379984389,83.0459364673864 54.9230548175711,83.0468425980135 54.9309715117434,83.044455684472 54.9375593271545,83.0366992709828 54.9435779253695,83.0258656784879 54.9486642067229,82.9910798564148 54.9565149951308,82.9839848724693 54.9595493955753,82.9668105215414 54.9713456869884,82.9513421611695 54.9867598818885,82.9487155771103 54.9945845213565,82.9458017118232 54.9974843397556,82.930956692427 55.0052002965814,82.9206144783925 55.009243785233,82.9185642534195 55.0100450677819,82.9156961123804 55.0111660637911,82.8691163089421 55.0330232906245,82.8312687588862 55.0440370938023,82.8264632212738 55.0470963264953,82.8237138375152 55.0447540975008,82.8046557194365 55.0367373985273,82.7964982081729 55.0309059519357,82.7946678907815 55.0316017730696,82.7936154245947 55.030602906857,82.7931388683365 55.0299274056716,82.7914912682739 55.0283465751258,82.7914463525096 55.0282768591815,82.7914344049164 55.0282265544699,82.7914451846998 55.0281831492278,82.791486866529 55.0281458711414,82.792501783137 55.0275815981919,82.7928437717656 55.0274466946402,82.7924745641838 55.0272474793664,82.7923847326554 55.02721200257,82.7922147714037 55.0271631897421,82.7921129024505 55.0271160760385,82.7920469661086 55.0270632983267,82.7871355171242 55.0227447647132,82.7812429281865 55.0229128989067,82.778531632996 55.0226180842731,82.7777741735484 55.0227926559948,82.7775053077839 55.0224076702671,82.7772894426211 55.0208850453531,82.77970618023 55.0178489439407,82.7791320669319 55.0167147437669,82.7784043417202 55.0161830152288,82.7786256866062 55.0160915432002,82.778734113261 55.0159958475776,82.7788214295066 55.0158886146441,82.778868591059 55.0157937941215,82.7788720944886 55.0156898569738,82.7784150316721 55.0147953064994,82.7780848109736 55.0142931689784,82.7770908251118 55.0132987131325,82.7644834192568 55.0027389214354,82.7584720730385 54.9974510523445,82.7581874867565 54.9972321585879,82.760217230141 54.9931607643978,82.7604113560739 54.9924734491366,82.7607026797205 54.9914420161143,82.7519028730288 54.9909852478332,82.7507523108129 54.9885144963879,82.7561791232758 54.9867598303463,82.7621133042112 54.9829835643253,82.7651060415802 54.9810475116568,82.7672671186592 54.9796757537378,82.7734462701726 54.9758857260116,82.7765117710796 54.9738434293431,82.7863153552698 54.9680278418825,82.7865251118887 54.9678583946562,82.7906529604507 54.9653724505173,82.7938443153291 54.96361527732,82.7980247153353 54.9617050578248,82.7998279934366 54.9605926337788,82.7998960857351 54.9600686713315,82.7999811561925 54.9599004283719,82.8001579446404 54.9597479672519,82.80067043351 54.9594063202058,82.8007465208146 54.9593555680417,82.8012886540886 54.9589608955698,82.8013412055327 54.9589374275995,82.8014119029455 54.9589218510489,82.8014836783368 54.9589207679111,82.8018773200942 54.9590210869828,82.8019698465685 54.9590262963467,82.8020673137768 54.9590137629253,82.8021444790597 54.9589896244731,82.8030032684714 54.9585287732502,82.80393652822 54.958985807708,82.8061128766589 54.9575149335337,82.8102042536204 54.9547854442511,82.8168374136783 54.9502621595006,82.8170768147016 54.9501781207567,82.8176340396723 54.9499269320825,82.8191845318527 54.9489869597144,82.8198879127201 54.9486931493524,82.8205108943697 54.948537653412,82.8220605780663 54.9477813691247,82.8221968524949 54.9477395277544,82.8223289946732 54.947725339857,82.8224671555639 54.9477365353983,82.8225129696434 54.9477101716992,82.8231887722316 54.9473512934815,82.8232291065879 54.9473299340385,82.8238393321604 54.9469931343658,82.827709543899 54.9448574244386,82.8298356765134 54.9437720353976,82.8299706034691 54.943891896066,82.8300923251901 54.9440048939582,82.8316408410769 54.9433131251703,82.8317846613539 54.9432486791837,82.8317831342179 54.943161994267,82.8322556480573 54.9424118007425,82.8323687459516 54.9423220180636,82.8331306071441 54.9420463736668,82.8332677798879 54.9419616985485,82.8337668838598 54.9414808891025,82.8369469199656 54.9382194065445,82.8392156152156 54.9352519314418,82.8392872109438 54.9351882982691,82.8393905172014 54.9351444310598,82.8395243661788 54.9351236844335,82.8467673924831 54.9346042411605,82.8468290169116 54.9345452517983,82.8628864026152 54.9333883615688,82.8632036875736 54.9316974541988,82.8631942552631 54.9316944606486,82.8630677724711 54.9316260218359,82.8629986021942 54.9315615571163,82.8629387743963 54.9314806276823,82.8626071163934 54.9308765937343,82.8625398325786 54.9307542167862,82.8640624769852 54.9304684798728,82.86377241098 54.9298853865251,82.8635889749989 54.9295508666443,82.8641797969613 54.9291840838956,82.8652133086957 54.9288523970947,82.8650980548447 54.9285951908346,82.8657094482271 54.9285041901123,82.8657732286123 54.928160574071,82.8660435316813 54.9278324404652,82.8694771621918 54.9278218071779,82.8694275751881 54.9284213446927,82.8697063224207 54.9290465782148,82.8697221327697 54.9290784254807,82.8697610298215 54.9291158472764,82.8710504715804 54.9301020667962,82.8711087722423 54.9301648821783,82.8722128017265 54.9309451370499,82.8736183956515 54.9316107959907,82.8737403868671 54.9322976049074,82.873902892102 54.9335421097387,82.8739092701405 54.9335803015393,82.8743479174938 54.9337238817411,82.8744964988418 54.9337937104606,82.8745980983004 54.9338610617715,82.8746498412608 54.9339364125296,82.874683707747 54.9340357101624,82.8747020333788 54.9341282982747,82.8768777529969 54.933558212232,82.8770221122631 54.9335072725915,82.8771202981236 54.9334345531754,82.8771518289901 54.933346505218,82.8771809344053 54.9330032918208,82.877192612504 54.9329164299808,82.8772446249589 54.9328526382783,82.8773734433707 54.9328036073702,82.8775286722518 54.9327712985497,82.8776300920474 54.9327637116504,82.8854799303261 54.9322832567236,82.8857144804468 54.9322626634579,82.8878476199205 54.9322275671413,82.8922055270268 54.9318925506128,82.892478075884 54.9318252992309,82.8925565886398 54.9318119315215,82.9000263497219 54.931186018393,82.9054738234363 54.930704925249,82.907643344679 54.9305759411395,82.9089019742236 54.9304278076183,82.9139599384308 54.9299904750539,82.916042502754 54.9298271128561,82.9163467621407 54.9297964533365,82.9166041294696 54.9297621807146,82.9168548492654 54.9297075199514,82.9170642465581 54.9296503299515,82.9172518147894 54.9295772422521,82.9174705545611 54.9294613649424,82.9182846977031 54.9289857741265,82.9212906403069 54.9270461890394,82.9213396883214 54.9269407831041,82.9220249232201 54.926500057353,82.9224316803807 54.9267099421089,82.9251737877855 54.9273584305635,82.9361909959245 54.9311831796455,82.9364435123509 54.9326403598212,82.9366861473091 54.9337101533903,82.9366999813645 54.9339197424768,82.9372170516421 54.9368142413327,82.955727287229 54.9376459725456,82.9588944774262 54.9378918710457,82.97817564719 54.9385871389829,82.9867280578524 54.9389631246367,82.9907442458247 54.9389709167809,82.9928801700757 54.9392787310713,82.9958104745325 54.9394047458982,82.9974751425855 54.939502894765,82.9993123770046 54.939505320102,83.0016793479467 54.9395181176224,83.0028862345309 54.9394554200539,83.0029601658788 54.9394602707334,83.0039578348334 54.9396224069417,83.0209588109114 54.9401971028063,83.0220080431633 54.9403879266436,83.0266570942532 54.9410910463577,83.0268749357096 54.9411288697836,83.0298390168211 54.9414058104826,83.0308255466661 54.9405717833674,83.0348949149032 54.9412487383322,83.0353842272384 54.9406946980588,83.035428693845 54.9406018154551,83.0356070094289 54.940230231293,83.0356768085264 54.9401510221711,83.0357590043749 54.9400717096889,83.0365537439068 54.9394700236938,83.0366110564219 54.9393910194866,83.0367158898156 54.9390276806998,83.0368063501647 54.9388632715291,83.0370690175538 54.9384616892405,83.0371368403577 54.9383400062287,83.0376529224884 54.9368569197755,83.0377163435475 54.9366573576715,83.0378807352445 54.9350383238238,83.0379005880123 54.9349387706227,83.0379436173144 54.9348174898217,83.0387619825382 54.9332300710464,83.0387942320569 54.9331373260329,83.0388003406009 54.9330166591342,83.0388129170149 54.9322932178733,83.0388173187597 54.932130277927,83.0390547434893 54.9314740211907,83.0391362206856 54.9313804463143,83.0394041881348 54.9310782490739,83.0394594345248 54.9309568017893,83.0395003078702 54.9307929273752,83.0395322878944 54.9302040062533,83.039515399567 54.9301193578109,83.0393978100963 54.9299795326462,83.0393927795307 54.9298803798447,83.0394113746571 54.9297665164093,83.0398117537792 54.9289163499914,83.0398522677986 54.9287454990073,83.0399359009515 54.928205326394,83.0399501841645 54.9280065988583,83.0398412185206 54.9268243820076,83.039433113887 54.9255695516387,83.0389728171354 54.9249958856384,83.0388915196022 54.9248413820951,83.038589056846 54.924222484405,83.0384808098543 54.9237847746358,83.0373567479393 54.9195713874499,83.037120221525 54.9187815153893,83.0369857437269 54.9185567198921,83.0367932347615 54.918397080251,83.0365866222462 54.9182090949845,83.0364313035336 54.9180628262474,83.0363262904769 54.9179297744141,83.036269696614 54.9177818524765,83.03560413482 54.9161710428945,83.0354501635803 54.9159228429936,83.0352018692357 54.9157320579643,83.0347062686935 54.91539168903,83.0343278982958 54.9151466856412,83.0340340593664 54.9149002866298,83.0337536053347 54.9146375178744,83.0324169121919 54.9131749865801,83.0292645441969 54.9092763302598,83.0280623288521 54.9077893316619,83.0269080835436 54.9061829251705,83.0265160587536 54.905442526048,83.0251022003279 54.9033791907459,83.0246269017111 54.9023332795265,83.0239756231301 54.9005146205622,83.0218693432834 54.8946295260066,83.0215658923804 54.8938114221888,83.0212838213812 54.8932506839448,83.0185128780558 54.8877473476316,83.0182430241445 54.887255659416,83.0151277565707 54.8827628103611,83.0148636518771 54.8823158129976,83.0144395572315 54.8813245980335,83.0141580252215 54.8808659054572,83.0139777333439 54.8806872537248,83.0137996872546 54.8805105133086,83.0134551833432 54.8801550663466,83.0127734518741 54.8792480887522,83.0116542408616 54.8795704686537,83.011420050067 54.8793027147041,83.0090505638421 54.8799846801472,83.0088619176324 54.880025196676,83.0085807449485 54.8800605969262,83.0084428535524 54.8800921728895,83.0077309386897 54.8803643659695,83.0073220255724 54.8800195636407,83.0071623051149 54.8800636459974,83.00528770078 54.8807520066716,83.0051474737641 54.8808198602065,83.0050939341732 54.8808622879871,83.0037419696706 54.8799917602068,83.0009096714113 54.8775158340241,83.0008816439744 54.877497435072,82.9977230776039 54.8736495438095,82.9974977801307 54.8734730309658,82.9947218062397 54.873676214497,82.9930214750699 54.8737085707725,82.9925285694735 54.8736917207026,82.9920898322887 54.8736411187631,82.991257543178 54.8734902946279,82.9908849219982 54.8734226871902,82.9906262970278 54.8733992726612,82.9905294586402 54.8688482224148,82.9855287171166 54.8689151655099,82.9812863333558 54.8689829355879,82.9812988199382 54.8705911879443,82.9786967598863 54.8706148625608,82.9786972988754 54.8716758122723,82.9764929229997 54.8716848580085,82.9764935518204 54.8726634912956,82.9664891043327 54.8726647835121,82.9561443750154 54.8727438670824,82.9421444906385 54.872920331431,82.9418333142241 54.8729031709014,82.9416427815523 54.8728819269827,82.9415127054992 54.8728255349203,82.9414617710226 54.872780927761,82.9414277248733 54.8727209173564,82.9414197298673 54.8726054448882,82.9413660106133 54.8699781759466,82.9413545121777 54.8694179330331,82.9413440018888 54.8688946431983,82.9413438222258 54.8666001105177,82.9334712565703 54.8671581179784,82.9330277583146 54.8671756428236,82.9299694439298 54.8673594723042,82.9296148788871 54.8673944701165,82.9293040617988 54.8674460621093,82.9273274986792 54.8675627383467,82.9272987525901 54.8670594307286,82.9272552741303 54.8653474864332,82.9270509972347 54.8642666209949,82.9270620465127 54.864197860698,82.9270914214225 54.8641350457379,82.9271642747921 54.8640382639781,82.9271211556584 54.8639925613996,82.9271062436247 54.8639254550311,82.9268671120961 54.8615069662347,82.9268490559589 54.861323368586,82.9268104284017 54.8611311873301,82.9267474565002 54.8609451578974,82.9267211358624 54.860888904248,82.9256646272567 54.8586422616805,82.9256333658849 54.8585423643313,82.9256460321304 54.8584418462519,82.9256962479547 54.8583581844084,82.9257694606504 54.8582943262096,82.9264015152843 54.8580284475046,82.9264505632988 54.8579855820262,82.9264843399535 54.8579319096258,82.9265044622159 54.8564466346352,82.9265121877273 54.855876120201,82.9265209912171 54.8552336677483,82.9265145233471 54.8550401646905,82.9264492158259 54.8530514558734,82.9263209364033 54.8510303779879,82.9262783562589 54.8502744323289,82.9261242053561 54.8475495074341,82.9262257149832 54.8472325090417,82.9270495599303 54.8445484481259,82.9270514463924 54.8445204650501,82.9272551842988 54.8438348477665,82.9278202246125 54.8411529403686,82.9272697370064 54.8379609242879,82.9279052950699 54.8337614225461,82.9287545623395 54.8332353934534,82.9295479543985 54.8326664133816,82.9326102213705 54.833253812607,82.9330779741389 54.8330677580739,82.9335098841275 54.8329567768609,82.9344637152962 54.8326332998087,82.9347757001944 54.8327389527074,82.9350833731792 54.8328044552961,82.9354733318441 54.8328377756876,82.9360448400278 54.8328499345192,82.9376603702348 54.8328274794826,82.9379164799223 54.8328004713345,82.9380928192125 54.8327605282164,82.9382513718602 54.8326855571536,82.938716968672 54.8328297560306,82.9384471147606 54.8329989445838,82.9383542289602 54.833125706185,82.938318835338 54.8332625565281,82.938362852787 54.833387144263,82.9384934678292 54.833490570417,82.9406581381694 54.8341749665223,82.9409905148245 54.8342470374961,82.9413497511066 54.8342800462696,82.9423387064029 54.8342922564047,82.9425807125405 54.8343138310835,82.943094728546 54.834471941567,82.9430442432271 54.834595025183,82.9430405601344 54.8347250412221,82.9431322781249 54.8348650421076,82.9433354770422 54.8349897283706,82.9435914070666 54.8350637121538,82.944612162724 54.8351423003735,82.9449673565873 54.8351423521103,82.945222298465 54.8351061880967,82.9453870494881 54.8350297210199,82.9458661210291 54.8351960548346,82.9456724442538 54.8352772813629,82.945614502918 54.835364767842,82.9456292352887 54.8354869692181,82.9457361348075 54.8356267087802,82.9459320573709 54.8357477194356,82.9462026299345 54.8358618488619,82.9464235256629 54.8359051517375,82.947674429696 54.8359758227585,82.9478351383003 54.83597111481,82.9479765331261 54.8359477820022,82.9481177482887 54.8358897344705,82.9483946090593 54.8360114686365,82.9481935660987 54.8361955436563,82.9481738031625 54.836318311605,82.9482305766884 54.8364335775904,82.9483912852927 54.8365787977776,82.9486345490717 54.8366931835279,82.948949947568 54.8367851678536,82.9491967147765 54.8368285214733,82.9502684049104 54.8368955177271,82.9505187653801 54.8368855329643,82.9508198806633 54.8367934971326,82.9510588325289 54.8369208158975,82.9507741564154 54.8371916450103,82.9507278931783 54.8374021506625,82.9507419967282 54.8375880817509,82.950874049075 54.8378843074194,82.951115785718 54.8381197964801,82.9518046138778 54.8384986868037,82.9520241621332 54.8385955815871,82.9526878374652 54.8387710572924,82.9528606733258 54.8388510350583,82.9533304922194 54.8391476653106,82.9536035800658 54.8392880647082,82.9541747289234 54.8394561398371,82.9543864618359 54.8394940588137,82.9547709407775 54.8395056465975,82.9549624615961 54.839549876724,82.9550986461932 54.8396126782472,82.9554958812118 54.839898129079,82.9558119085287 54.8402566210114,82.9560445721873 54.8404009997631,82.9563117311528 54.8405121674289,82.9566021564842 54.8405756399421,82.9573860264011 54.8406428886246,82.9575316433087 54.8406623907216,82.9576284816963 54.8407168103164,82.9576626176771 54.8407873694536,82.9577511017326 54.8411939097625,82.9577976344643 54.841328094582,82.9579132476414 54.8414643998304,82.9581095295309 54.8415748403677,82.9586228268843 54.8417855818002,82.9601442136495 54.8420791385398,82.9603068985474 54.84212988355,82.9604175709904 54.8422083028287,82.9604649122059 54.8423041541543,82.9605641760448 54.8425182540534,82.9606914673206 54.842643589128,82.9610991227965 54.8428379792826,82.9614636591388 54.8429558647132,82.964605516845 54.8436848949122,82.9651180057146 54.8437562247458,82.9655761465095 54.8437893291942,82.9662451219016 54.8438055710543,82.9664642209994 54.8438344856871,82.9666254685929 54.8438987288581,82.9672735132388 54.8442342710361,82.9673051339368 54.8443298589246,82.9672611164879 54.8444207913486,82.9671202606514 54.8446218454176,82.9670844178715 54.844771536168,82.967125291217 54.844944709156,82.9672396467526 54.8451021055849,82.9677598611336 54.8453298456996,82.9678443027703 54.8453910865196,82.9678688267776 54.8454716201253,82.9680893631799 54.8459126124726,82.9681736251535 54.8459745765284,82.9682936400755 54.8460149203533,82.9684096125786 54.8460575916626,82.9684902812912 54.8461267449494,82.9685147154669 54.8462108459446,82.9686991395947 54.8466539508151,82.9688416123988 54.8468230814248,82.9690192093305 54.8469610232045,82.9693026278026 54.8470996368913,82.970717115049 54.8475764022721,82.9710918921855 54.8475952286479,82.9710927006693 54.8476267783241,82.9713626444121 54.8476404326025,82.9717149636666 54.8476821194997,82.9721121986852 54.8477556662529,82.972655320106 54.8478854847378,82.9733595992887 54.8481121747398,82.9737649191449 54.8482904536619,82.9814220687952 54.8522393858022))"},"adm_divs":[],"attributes":null},{"id":"141360258613345","name":"Новосибирск","type":"geo","geo_type":"city","short_name":"Новосибирск","synonym":null,"dist":0,"geometry":{"centroid":"POINT(82.9204115489698 55.03011111017)","selection":"MULTIPOLYGON(((82.8046557194365 55.0367373985273,82.8237138375152 55.0447540975008,82.8287484455251 55.0490427787456,82.827504189025 55.049930544056,82.8245913118847 55.052616208903,82.8234864739168 55.0538767985827,82.8228815484045 55.0548843978938,82.8217046655508 55.0565917325255,82.8215412620006 55.0567238109813,82.8213036576079 55.0569941922811,82.8211659458749 55.0571571405098,82.8207684413616 55.0574909070404,82.8202769730697 55.0578107275765,82.8187864883503 55.0586221526748,82.8183419121162 55.0589429417144,82.8171843430411 55.060326086702,82.8168384018251 55.0606155820985,82.814412950558 55.0623506070409,82.8142288857563 55.0625173918366,82.8137863756474 55.0631496449763,82.8134461836493 55.0636357374463,82.8128700940575 55.0643850048358,82.8113556243201 55.0663543305668,82.810340528049 55.0674976709746,82.8097775538604 55.0680024340283,82.8089299035584 55.0686366580049,82.8083000947126 55.0689593213819,82.808002303196 55.0690518043634,82.8073760876114 55.0691386805622,82.8067213056008 55.0693231311205,82.8061851012077 55.0695787166713,82.8053633223858 55.0701537653329,82.8047035098096 55.0708258622706,82.8037008102895 55.0722026819153,82.8025208731638 55.074487967299,82.8030838473524 55.0802473010254,82.8032473407341 55.0805268307736,82.8036378383881 55.0813124963649,82.8038611595677 55.0820224051525,82.8039235924799 55.0828052133307,82.8039158669685 55.0835420386124,82.8038155251513 55.0840450567563,82.803722819014 55.0844148479262,82.8036737709994 55.0848387255897,82.8038355575821 55.0860040060962,82.8042187788823 55.0871758335427,82.8042237196164 55.0875047226055,82.8041867988582 55.0877831733851,82.8039765930817 55.0882073752311,82.8038395101693 55.0888504815305,82.8040015662466 55.090549375799,82.8034807230449 55.0933766105587,82.803112683273 55.0950995233594,82.8030008430201 55.0970645618608,82.8030572572199 55.0974845532449,82.8046540126375 55.1001307932501,82.8064175852032 55.1021158850772,82.8068131134228 55.1050273529032,82.8069571133629 55.1054954641629,82.8072582286461 55.1061100799081,82.8077629021727 55.1066904103291,82.8083903753987 55.1072688823763,82.8092554530173 55.1080663553389,82.8093167181197 55.1081413279757,82.8099093367126 55.1092858379536,82.8099363760027 55.1094117818929,82.8099094265442 55.1101023854213,82.8105250420084 55.1104173151657,82.8116358986887 55.111429811091,82.8133892304602 55.1139930246889,82.816150382149 55.1174572403879,82.8176626060983 55.1204546634981,82.8178396640408 55.1204491668614,82.8178666134993 55.1204515299016,82.8221422349256 55.1208163610775,82.8257504979274 55.1212970269714,82.8280464121305 55.1216729974694,82.8284812865596 55.1217281162243,82.8317521423406 55.1221433794029,82.8367068002901 55.1227722760671,82.8452780755736 55.1237990468619,82.8624450603161 55.125853433798,82.8701110134562 55.1266101649057,82.8848736573409 55.1286985615242,82.8876733467553 55.1289289096925,82.8893403504281 55.1286712894458,82.8895145337617 55.1290411301136,82.889836400128 55.1289912601165,82.8905425657728 55.1304842514839,82.8906670722712 55.130798917842,82.8906882725119 55.1308281400367,82.8908564371331 55.1308020506266,82.8917322945351 55.1306638997264,82.8966846168649 55.1298816176563,82.8973444294411 55.1297690914468,82.8975962272153 55.1297133674876,82.8978460486958 55.1296433144,82.9000052393127 55.1290349669866,82.9001772666896 55.1289593145243,82.9002950358234 55.1288544896604,82.9003733689161 55.128750178119,82.9016974856449 55.1281809024527,82.9022130287865 55.1280577911569,82.9135346759753 55.1252679884628,82.9184852016745 55.123547557492,82.9231268865791 55.1218945507728,82.9236243735835 55.1221334139591,82.9240301425973 55.1218558188441,82.9244853189518 55.1215970742137,82.9250907834533 55.1213239958707,82.9257361331534 55.1210933983516,82.9290945746746 55.1200253584842,82.9295466069256 55.1198637450386,82.9299053042185 55.1197181588129,82.9302140551817 55.1195676403857,82.931366054702 55.1188900949541,82.9316990601778 55.1187366965384,82.9320978223324 55.1185926987622,82.9325203898421 55.1184593346791,82.9599599691847 55.111458585023,82.9648070987948 55.1100429857656,82.9655358121532 55.1104930027568,82.9679672821328 55.1121640023132,82.968470877681 55.1124554348249,82.9689127589693 55.1126450292351,82.9734356865933 55.1141117607884,82.9736502941147 55.1142085065575,82.9738048941751 55.1142983160156,82.9746840753436 55.1146694201195,82.9777189436995 55.1151073113353,82.9790678539301 55.114876883434,82.9850706661532 55.1156949093117,82.9853540846254 55.1157494197989,82.990185673381 55.1166782444633,82.9911804677266 55.1166553310775,82.9908955221185 55.1172856498975,82.9897942774117 55.1184888227698,82.9852495207263 55.1195237176661,82.9867720753013 55.1210164465999,82.9850595270437 55.1223809055341,82.9803726568803 55.1223962645498,82.981538310793 55.1253654776745,82.9826912984602 55.1285612251055,82.9846086626026 55.1296398220141,82.9877666899839 55.1325720346388,82.9877665103209 55.1325721373485,82.9877666899839 55.1325721373485,82.9910494933582 55.1337388510485,82.9987683572685 55.1339694782559,82.9998730155734 55.1339117060344,83.0009244037819 55.1337093742174,83.001855687237 55.1334164534451,83.0025711055293 55.1329551913079,83.0030855706925 55.1323566518326,83.0045562924756 55.1282714509024,83.0029178552289 55.1281012936064,83.0027535533635 55.1215107228929,83.0030384091401 55.1196414612688,83.0057470992163 55.1195755002357,83.0036976827271 55.1138530687467,83.0032543641344 55.1126163589186,83.0031255457226 55.1123069442656,83.0028905464443 55.1118561256016,83.0003320546836 55.1069460654823,83.0006031662363 55.1068079348208,83.0006789840463 55.1067312124874,83.0006945249007 55.1066289500726,83.0006800620247 55.1065932866362,82.9998980785698 55.1046707028135,82.9992587475821 55.1033160201539,82.9984907778457 55.101856909784,83.000894489883 55.101457470896,83.0034051912706 55.1010393714894,83.0166899268498 55.0937072477905,83.0172797606653 55.0934283756168,83.0200181849774 55.0917621959364,83.019314983773 55.0913768447294,83.0203779602487 55.090738765701,83.0215893384094 55.0904162265523,83.0229333079059 55.0898781242884,83.0231318355837 55.0896142885656,83.0235783881115 55.0897768983567,83.0255275526149 55.0908284736885,83.0285923348698 55.0888115633283,83.0261596072488 55.0874328474402,83.0283387404651 55.0867119293016,83.030847465559 55.0878902653678,83.0325275846349 55.0868048339732,83.0370302103335 55.0841638304331,83.0360775469747 55.083486198735,83.0354037206801 55.0828742173631,83.0336445498592 55.081826186513,83.0352695123766 55.0804784942755,83.0373640242931 55.0788105921991,83.0387455433685 55.0795369493473,83.0451810740639 55.0779485627039,83.0478235583037 55.0765113598975,83.0479194085445 55.0764594700838,83.0511401383327 55.0748599039933,83.0536304479633 55.0744842643721,83.055809311685 55.0740505566821,83.059458088706 55.0728484628757,83.059604963255 55.0728166781057,83.0602567808251 55.0725702681346,83.0606163764333 55.07240095362,83.0609411174085 55.071457675561,83.0610807156037 55.0712932425349,83.0631366897945 55.0700720862949,83.0634013334772 55.0699879381947,83.0637141268591 55.0699625805723,83.0648119579678 55.0700087694951,83.0650980713858 55.0699714788879,83.0674527354086 55.069148093425,83.0702962626089 55.0681169860127,83.0735177110493 55.0672744271573,83.075159382231 55.0667047897095,83.0753718337957 55.0666297393455,83.0862148586011 55.0637816309124,83.0838202195483 55.0589343496438,83.082265325623 55.0559626173594,83.080659317558 55.052543036057,83.0807362133463 55.0524920928574,83.0814139922282 55.0520335496862,83.0811840235155 55.0487293724604,83.0796052344036 55.0478185247381,83.0796363161125 55.0475148870721,83.0796664096745 55.0472340459138,83.07991299722 55.0449440645302,83.0797737583509 55.0449390721815,83.0790646282657 55.0410661602162,83.0786445760388 55.0381211562281,83.0776336120181 55.0235552010799,83.0759400182129 55.0235222957669,83.0725028842728 55.0090849176687,83.0725852597844 55.0089503124598,83.0729274280761 55.0076322599351,83.0729363213974 55.0074578282581,83.0721686211556 55.002467967741,83.0721953011195 55.0022932044709,83.0721689804817 55.0021296208262,83.071879183971 54.9977239464665,83.0726726658615 54.9969289619676,83.0730885858381 54.9967114566585,83.0736938706765 54.9966193218579,83.0743245778375 54.9966344715544,83.0765040703798 54.9969479247058,83.0775135970961 54.9969306624309,83.0783787645462 54.9968019938375,83.0804703120223 54.9962536146932,83.0820912321209 54.9944844456937,83.0782938737519 54.99301914863,83.0767868600312 54.9908344507998,83.0832875185848 54.9846255636165,83.083675500956 54.9846655625101,83.0862902272535 54.9846349448039,83.0868466437405 54.9846069558702,83.0873619173874 54.9850219941898,83.0876942940426 54.9851914205466,83.0881300667869 54.9852930657086,83.0944300417059 54.984949986483,83.0949313016345 54.984823598986,83.0952846988672 54.984617367962,83.0955202371347 54.984320003743,83.0955997380374 54.98398346252,83.0954314835847 54.983079235629,83.0956846288317 54.9830031522185,83.0960766536217 54.9828956248762,83.0970232084366 54.9826998996313,83.0973617834672 54.9826145884872,83.0976839193281 54.9824883998281,83.0979390408688 54.9823553033534,83.0992893884039 54.981354488268,83.099844637081 54.9808589943781,83.1002653181285 54.9801710044775,83.1004392319675 54.979699364248,83.1006895026057 54.9786866774044,83.1007890359392 54.9784198401703,83.1010080452054 54.9781669721055,83.1010566440623 54.9780802078337,83.1014640300437 54.977433259055,83.1016665103087 54.9772077602343,83.1019551390095 54.9769863329766,83.1060364548398 54.974847937577,83.1069173428074 54.9743597362055,83.1073609308947 54.9740511077966,83.1078602145296 54.9735327861561,83.1086328555055 54.9729379428609,83.109111837215 54.9725813007689,83.1096193853505 54.9720596086845,83.1097922212112 54.9721181305199,83.1102640163984 54.9723025639753,83.1112418325852 54.9727106141849,83.1125016299396 54.9720244955423,83.1107292538841 54.970527234347,83.1109823991311 54.9699760726603,83.111495606653 54.9691349035668,83.1117769589999 54.9688850709419,83.1120874167621 54.96869453707,83.1126586554513 54.9684795601493,83.1131776121909 54.9683420856985,83.1137565763916 54.9681888315552,83.114769876032 54.9679828244755,83.1165854610528 54.967726693549,83.1178908029921 54.9675915885972,83.1196603044388 54.9675101644392,83.1210226893987 54.9675190339565,83.1225468609412 54.9676043256101,83.1240793868159 54.9677608306824,83.1253708946999 54.9678981524232,83.1284041460883 54.968398240923,83.1302646468732 54.9687785886594,83.1312017693776 54.9690732834868,83.1319432388131 54.9694012352935,83.1325734968165 54.9696484864968,83.1331642289473 54.9698156573551,83.1339866365899 54.9699493626025,83.1347839812361 54.9700157252036,83.1351151002498 54.9700182518273,83.1353392299132 54.9700199018672,83.136560489542 54.9699613254105,83.137910657414 54.9697742514362,83.1386957849723 54.9695616006896,83.1392582201717 54.969346319022,83.1409397765521 54.9684084509554,83.1417746707771 54.9679427573938,83.1421154017644 54.9677989899816,83.1431760426203 54.9674040910486,83.1437794409967 54.9671256277275,83.1446205335972 54.9666502760647,83.1450840642838 54.9663329764727,83.1453898508065 54.9660324858273,83.1462634624204 54.9649477201312,83.1468481758388 54.9639889660541,83.1473283253581 54.963276241779,83.1475309852862 54.9629752125399,83.1481289937709 54.9616526066063,83.1487306853482 54.9606152755693,83.1491351967206 54.9601406205121,83.14952542488 54.9598215674656,83.1499689231358 54.9595670865464,83.1504750339669 54.9593516481564,83.151969381442 54.9587977542089,83.1524524954018 54.958618674469,83.1537512796396 54.9580637904143,83.1546388151403 54.9577690663942,83.1557237105089 54.9574718127996,83.1564233184522 54.9572800900278,83.1574270061191 54.9570458125337,83.1579092217637 54.956982626494,83.1583722134611 54.9569999059514,83.1589091365064 54.9570449356669,83.1605524246556 54.9566867597648,83.1608602773035 54.956566163531,83.1612551767024 54.9564715122556,83.1618310866311 54.9563789755889,83.1628216588949 54.9563833084141,83.1635036598586 54.9564830148476,83.1629793132272 54.9544903866833,83.1608766266417 54.9533706441368,83.1577898356624 54.9514916638925,83.1514580603823 54.9495107571271,83.1512762413688 54.9494282129274,83.1510893917897 54.9493255999327,83.1503483715118 54.9487719289174,83.149813065434 54.9483721481139,83.1489884120032 54.9475298043238,83.1489069348069 54.9473963340086,83.1465079838407 54.9440592773054,83.1466395870298 54.9437535119133,83.1470567646477 54.9430152486606,83.145950938533 54.9400280026132,83.1467371440696 54.9385822365939,83.147315209955 54.9357091274085,83.1449477898552 54.9317079832358,83.1442533921406 54.9311950507701,83.1438993660871 54.9305700054862,83.1433208510442 54.9282399616641,83.1435285415378 54.9276204452211,83.1442585125377 54.9267660006655,83.1472870926866 54.9237610796321,83.147402077043 54.9235814307843,83.1502611450977 54.9205049746514,83.1504324538224 54.9202669721186,83.1507050925111 54.9193400395095,83.1507783052068 54.9191560857123,83.1508833182635 54.919001921147,83.153023734091 54.9164856922847,83.1530509530441 54.9164314265415,83.1530698176651 54.916356301153,83.1530477191091 54.9152429316182,83.1525726899868 54.9149102004498,83.1427963247498 54.9089520707143,83.1363732806368 54.9046680258991,83.1350234720909 54.9037245679058,83.1333597023531 54.9030823096709,83.1326929727493 54.9025924614413,83.1304135875473 54.901391781244,83.1297410188941 54.9009923041227,83.1297197288219 54.9008853836623,83.1297623987979 54.9008130701465,83.140071734493 54.8870905735969,83.1401861798602 54.886938559703,83.1414627757105 54.8851970244609,83.1328019383932 54.8818856573269,83.1296264836954 54.8806711817483,83.1292417352592 54.8805031232685,83.1288453087243 54.8803057621847,83.1271646506593 54.8793786327679,83.123657448127 54.8773513284881,83.1235528842279 54.8752593156113,83.123418765756 54.8722768582615,83.1228786087757 54.8661261031165,83.1229136430717 54.8650695568049,83.1235655504734 54.8605579988391,83.1253127737011 54.8551642198042,83.1253336146156 54.8542115867165,83.1253989221368 54.8474797359345,83.1254064679852 54.8471377038503,83.1261540459646 54.8454585340719,83.126121976109 54.8449268643036,83.1260926910307 54.8444250327877,83.1260348395264 54.8434503693929,83.1246537696086 54.8286461236243,83.1189833340407 54.826667498172,83.1184080529327 54.8264442065532,83.1169246649041 54.825986752428,83.1160380277186 54.8257498988611,83.1141040447434 54.8253329048705,83.1128329286164 54.8251074323872,83.1126455400482 54.8250596157061,83.1120998135131 54.8248083702012,83.1117987880613 54.8247177040863,83.1099822148938 54.8243738230501,83.1098509710308 54.8243343373501,83.1091464223534 54.8242757556115,83.1083930053247 54.824346084738,83.1056895254771 54.8250725531254,83.1049690766192 54.8252117077454,83.1042084730682 54.8252554877907,83.0998140943613 54.8252017200925,83.0985482782945 54.8250342066025,83.0973819955611 54.8246757864643,83.0949416322602 54.8235342131647,83.0940448441121 54.8230293210048,83.0894862533713 54.8199523232893,83.0895400624568 54.818878418983,83.0976684683052 54.8222998659253,83.101776553931 54.8224418247644,83.1016114435818 54.821849817397,83.101578834737 54.8218134344599,83.1014577418367 54.8217448605562,83.1014255821495 54.8217034573882,83.101213669574 54.8206934657115,83.1010370607891 54.8207040755427,83.1006078457464 54.8183191741699,83.1005115463479 54.8172523175175,83.1028614492996 54.8176241056638,83.1029399620555 54.8172683112587,83.1029756251722 54.8169990565576,83.1029671810086 54.8168748840905,83.1002708876833 54.8164484297639,83.0999907929777 54.8159034374592,83.0998435591026 54.8156168852269,83.099743666443 54.8146453048148,83.099746541052 54.8142805290867,83.099694528597 54.8137190982789,83.0993078936987 54.8123684437225,83.0992668406902 54.8122966442878,83.0991616479704 54.8108065313243,83.0990104615081 54.8102103154436,83.0989733610869 54.8100798580736,83.09890419081 54.809949141437,83.0986018178854 54.8093914813958,83.0985525003763 54.8092365341973,83.0984938403882 54.8090411021189,83.0984651841307 54.8088880690819,83.0984200887034 54.8083126368963,83.0957140037415 54.8085126801076,83.0955372152936 54.8085547698187,83.0954207038013 54.8086007940651,83.0952768835243 54.8086822294142,83.0951031493483 54.8087385040955,83.094874438277 54.8087543976666,83.0946364745582 54.8087330681822,83.0943641951956 54.8086624530127,83.094126590803 54.8085809140821,83.0925483406803 54.8086975017596,83.0923028311131 54.8087377793071,83.0919453914616 54.8088188002162,83.0917124583084 54.8088566962023,83.0891735498209 54.8090441047911,83.0879384561368 54.8055532959358,83.0876171287597 54.8045173748394,83.0874712423575 54.8040781565739,83.0872803503596 54.8036721226638,83.0870670903112 54.8033206582399,83.0865437318267 54.8025787310361,83.0824753517364 54.8037445587496,83.0830353614845 54.8045580189855,83.0832764693068 54.80504652218,83.0834462508955 54.805617289391,83.0839363717145 54.808427465134,83.0841613098616 54.8090222577573,83.0847447656387 54.8101423948337,83.0850002465055 54.8109645785668,83.08553770854 54.8120336201785,83.0855884633535 54.8122847898627,83.0858094489134 54.8133777118182,83.0859451843528 54.8142535602949,83.085896765159 54.8149629732884,83.0855607952428 54.8162365208175,83.0851233156994 54.8174887033326,83.0828880377779 54.8213962963099,83.082434478391 54.8225984809136,83.0822168165976 54.8238314217418,83.0823327891008 54.8250512322561,83.0823316212909 54.8259321577264,83.081979212205 54.8268890291465,83.0814960982452 54.8277786596321,83.080681416114 54.8288947062671,83.0799121887362 54.8297948482603,83.0792339606967 54.830509990455,83.0783768780841 54.8311459032334,83.0774865578061 54.8317664388945,83.0767308949891 54.8321907653433,83.0758068878878 54.8326062915306,83.0746132963698 54.8330242969359,83.0741154500393 54.8331128748247,83.0736375463082 54.8331182557183,83.0732610623726 54.8330529605965,83.0728063351758 54.8327652882791,83.0726106821069 54.8327099783846,83.0724028119502 54.8327307260714,83.0712398529834 54.8331248783555,83.0709233765088 54.8331576810893,83.0706228002147 54.8331134439577,83.0702623062912 54.8328996563415,83.0700968366158 54.8328620933472,83.0699007343893 54.8328795813571,83.0693138650142 54.8330595315049,83.0687760436536 54.8331468158334,83.0685371816195 54.8331619754516,83.0683151180813 54.8331297935933,83.0678952455175 54.8329791800861,83.0677073179601 54.8329575012148,83.0675400516542 54.8329659347628,83.0666444313159 54.8331382271053,83.0663859860087 54.8331481093164,83.0653486115186 54.8330931103827,83.0651461312535 54.8330743807194,83.0649663783652 54.8330302987149,83.0646868226488 54.8329105216639,83.0645651907593 54.8328765287169,83.0644205619985 54.8328651459885,83.0636595092898 54.8328717686672,83.0633844451498 54.8328460023017,83.0631849293252 54.8327939521236,83.0629974509254 54.8326631020255,83.0629269331756 54.8325977544275,83.0627865264967 54.8325779379932,83.0619478593475 54.8325229382828,83.0617395400331 54.8324875997651,83.0608806607899 54.8322072705741,83.0607374693336 54.8321320397807,83.0606508717402 54.8320363712584,83.060581970958 54.8319309234844,83.0605092972515 54.8318094874584,83.0604837850974 54.8316538501257,83.060490342799 54.8315046281303,83.0604547695137 54.8313475925985,83.0603921569384 54.8312489729373,83.0602883116916 54.8312123397595,83.0601587746276 54.8311890042009,83.0582839007981 54.8311728090048,83.0580030874403 54.831125827377,83.0577309877408 54.8310303634383,83.0575162903879 54.8309324156503,83.0573933110255 54.8308385035227,83.0573321357546 54.8307556123062,83.0573022218556 54.830666615305,83.0573242305801 54.8305382937022,83.0573926822047 54.8304526595024,83.0574426285346 54.8303773736964,83.0574454133119 54.8303097457083,83.0573851363564 54.8302431524678,83.0572793148159 54.830215728646,83.0571273198698 54.8302146420414,83.0569992201103 54.8302461018211,83.0568750729381 54.8302956716215,83.0567616157177 54.830363403119,83.0566389956814 54.8304603174322,83.0564510681239 54.8305645272243,83.0562799390623 54.8305997639402,83.0561159066914 54.8306117164757,83.0559789136106 54.8305939170277,83.0558271881591 54.8305307910152,83.0556397097593 54.8305157338944,83.0554066867746 54.8305378797609,83.0552261254025 54.8305975907516,83.0551080867742 54.8306698750824,83.0549586969424 54.8308139776748,83.0548486533201 54.8308908149331,83.0547004312982 54.8309554409044,83.0545285835844 54.8309985420752,83.0543613172785 54.8310086317784,83.0541520996488 54.8309994216905,83.0539833960385 54.8309767586561,83.0538668845461 54.8309877797223,83.0537236930898 54.8310358480934,83.0536479651114 54.8311116500908,83.0536219139681 54.8312295180335,83.0534798004902 54.8313802415518,83.0533112765429 54.8315087157027,83.0531134675173 54.8315997287584,83.0529320078299 54.8316374998924,83.0527763297912 54.8316272551226,83.052631970525 54.8316480551071,83.0525332456753 54.8316989684568,83.0525035114394 54.8317581603193,83.0525458220893 54.8318531568682,83.0525412406813 54.8319737649096,83.0523552894175 54.8321788132753,83.0522481204041 54.8322482490491,83.0521072645676 54.8322807937931,83.0519783563243 54.8322965746214,83.0518613058428 54.8323588700276,83.0517138923047 54.8325074162436,83.0517013158907 54.8325716257067,83.0517497350845 54.8326511500974,83.051800310235 54.8327124101589,83.0518100120401 54.8327816380557,83.0517603352048 54.8328574367752,83.0514971288266 54.8331577328286,83.0513791800298 54.8332260286558,83.0512489243136 54.8332551060865,83.0511311551799 54.8333045687142,83.0510433897766 54.8333846090513,83.0510053910401 54.833507592505,83.0510424914613 54.8336165543936,83.0510282082483 54.8337063727094,83.0509740398367 54.833782738816,83.0507544017497 54.8339813107126,83.0505597368276 54.8340722147176,83.0504240013882 54.8341440271846,83.0503674075253 54.8342143391233,83.0503524954916 54.8342967575976,83.0503292291257 54.8344488148432,83.050192595371 54.834626947186,83.0497394851417 54.8349775184465,83.0490920693164 54.8353257585187,83.047571491035 54.8360322146264,83.0474145553549 54.8360844675714,83.0472363296025 54.8360840019514,83.045944731887 54.8356636483689,83.04566984741 54.8356978459132,83.0455645648588 54.8357870387667,83.0455676191307 54.8358477767108,83.0456568218384 54.8359630440399,83.0493697385708 54.8369422857025,83.0494809500029 54.8369916920777,83.0495245182942 54.8370708973553,83.049508168956 54.8371395487013,83.0492457710615 54.8375175687539,83.0492241216632 54.8375777867575,83.0492408303275 54.8376264163512,83.0493052395334 54.8376697173338,83.0496147989803 54.8377584402293,83.0497037321934 54.8377621133013,83.0498030858638 54.8377382641944,83.0499120515078 54.8377278657725,83.0501606153469 54.8377391436628,83.0503359664903 54.83773609139,83.0504736782234 54.8377046374471,83.0511607097527 54.8378346952035,83.0511707708839 54.8381831692901,83.0513348930863 54.8383822885984,83.051828696998 54.8385958919811,83.0524497023539 54.838840481727,83.0533996707668 54.8395201313226,83.0543129879162 54.8401281229706,83.0547050127062 54.8405180646348,83.0549558223335 54.8409029330525,83.0552980804568 54.8416052567249,83.0549919346079 54.8421218140114,83.053363827987 54.8432212737837,83.0530544482032 54.8433315543341,83.052654069081 54.8434389896462,83.0522816275642 54.8435000264317,83.0517677013902 54.8435415624288,83.047944651204 54.8434274029917,83.0417833761648 54.843080525983,83.0411180838654 54.8429586062307,83.0400531310961 54.8417687701161,83.0414517181619 54.8387796448221,83.0429728354325 54.8358307038737,83.0436984046875 54.8342880139005,83.0437018182856 54.8342809258133,83.043713945542 54.8341143812753,83.0435801863961 54.8340146818708,83.0433499481888 54.8339883471141,83.0431659732186 54.8340272542535,83.0430661703906 54.8341026884674,83.0403256799533 54.8397655948917,83.0398453507709 54.8406436645703,83.0397108729728 54.841025428037,83.0395476490857 54.8413722709824,83.0394100271842 54.8416251721845,83.039333490722 54.8418123252956,83.0392642306136 54.8419036772176,83.0391890416243 54.8419780621519,83.0390982219491 54.8420369803023,83.0386352302516 54.842291273984,83.0378931319954 54.8426989888657,83.0377682661709 54.8427436810356,83.0375921963753 54.8427695445372,83.0374141502859 54.842776217318,83.037251465388 54.8427645787462,83.0357838877083 54.8424883556578,83.0342966369239 54.8419810106479,83.0337406695946 54.8418543285832,83.0331741919764 54.8417899787011,83.0326597268132 54.8417764258993,83.0152388781713 54.840784576059,83.014023816918 54.8407700400581,83.0129051448947 54.840793939103,83.0117105652299 54.840813648045,83.010572759091 54.8408875694239,83.0095293658885 54.8409931489893,83.0079822873062 54.8411989792048,83.0059793137172 54.841543906702,83.0042249937989 54.8419497669253,83.0020179229773 54.8425786197777,82.9999896168973 54.8433354338039,82.9982096949933 54.8441401829529,82.9899752879415 54.8482692484934,82.989853835715 54.8482557495877,82.9897110035849 54.8482554909879,82.9895930547881 54.8483089176654,82.9895337659793 54.848376929258,82.9895685307808 54.8484459751301,82.9897543922131 54.8485923933639,82.9874732103806 54.8496849017643,82.9872012903441 54.8494990781242,82.9845175734328 54.8508052041665,82.9844185790885 54.8507979638299,82.984300181134 54.8508033940825,82.9841541150688 54.8508467843605,82.9818368209619 54.8521807411229,82.981768998158 54.852210166903,82.9816987499027 54.8522293014058,82.9816205066415 54.8522388169389,82.9815925690362 54.8522409372476,82.9815474736089 54.8522516422191,82.981498695089 54.8522524179416,82.9814220687952 54.8522393858022,82.978060393339 54.8505058668788,82.9737649191449 54.8482904536619,82.9733595992887 54.8481121747398,82.972655320106 54.8478854847378,82.9721121986852 54.8477556662529,82.9717149636666 54.8476821194997,82.9713626444121 54.8476404326025,82.9710927006693 54.8476267783241,82.9710918921855 54.8475952286479,82.970717115049 54.8475764022721,82.9693026278026 54.8470996368913,82.9690192093305 54.8469610232045,82.9688416123988 54.8468230814248,82.9686991395947 54.8466539508151,82.9685147154669 54.8462108459446,82.9684902812912 54.8461267449494,82.9684096125786 54.8460575916626,82.9682936400755 54.8460149203533,82.9681736251535 54.8459745765284,82.9680893631799 54.8459126124726,82.9678688267776 54.8454716201253,82.9678443027703 54.8453910865196,82.9677598611336 54.8453298456996,82.9672396467526 54.8451021055849,82.967125291217 54.844944709156,82.9670844178715 54.844771536168,82.9671202606514 54.8446218454176,82.9672611164879 54.8444207913486,82.9673051339368 54.8443298589246,82.9672735132388 54.8442342710361,82.9666254685929 54.8438987288581,82.9664642209994 54.8438344856871,82.9662451219016 54.8438055710543,82.9655761465095 54.8437893291942,82.9651180057146 54.8437562247458,82.964605516845 54.8436848949122,82.9614636591388 54.8429558647132,82.9610991227965 54.8428379792826,82.9606914673206 54.842643589128,82.9605641760448 54.8425182540534,82.9604649122059 54.8423041541543,82.9604175709904 54.8422083028287,82.9603068985474 54.84212988355,82.9601442136495 54.8420791385398,82.9586228268843 54.8417855818002,82.9581095295309 54.8415748403677,82.9579132476414 54.8414643998304,82.9577976344643 54.841328094582,82.9577511017326 54.8411939097625,82.9576626176771 54.8407873694536,82.9576284816963 54.8407168103164,82.9575316433087 54.8406623907216,82.9573860264011 54.8406428886246,82.9566021564842 54.8405756399421,82.9563117311528 54.8405121674289,82.9560445721873 54.8404009997631,82.9558119085287 54.8402566210114,82.9554958812118 54.839898129079,82.9550986461932 54.8396126782472,82.9549624615961 54.839549876724,82.9547709407775 54.8395056465975,82.9543864618359 54.8394940588137,82.9541747289234 54.8394561398371,82.9536035800658 54.8392880647082,82.9533304922194 54.8391476653106,82.9528606733258 54.8388510350583,82.9526878374652 54.8387710572924,82.9520241621332 54.8385955815871,82.9518046138778 54.8384986868037,82.951115785718 54.8381197964801,82.950874049075 54.8378843074194,82.9507419967282 54.8375880817509,82.9507278931783 54.8374021506625,82.9507741564154 54.8371916450103,82.9510588325289 54.8369208158975,82.9508198806633 54.8367934971326,82.9505187653801 54.8368855329643,82.9502684049104 54.8368955177271,82.9491967147765 54.8368285214733,82.948949947568 54.8367851678536,82.9486345490717 54.8366931835279,82.9483912852927 54.8365787977776,82.9482305766884 54.8364335775904,82.9481738031625 54.836318311605,82.9481935660987 54.8361955436563,82.9483946090593 54.8360114686365,82.9481177482887 54.8358897344705,82.9479765331261 54.8359477820022,82.9478351383003 54.83597111481,82.947674429696 54.8359758227585,82.9464235256629 54.8359051517375,82.9462026299345 54.8358618488619,82.9459320573709 54.8357477194356,82.9457361348075 54.8356267087802,82.9456292352887 54.8354869692181,82.945614502918 54.835364767842,82.9456724442538 54.8352772813629,82.9458661210291 54.8351960548346,82.9453870494881 54.8350297210199,82.945222298465 54.8351061880967,82.9449673565873 54.8351423521103,82.944612162724 54.8351423003735,82.9435914070666 54.8350637121538,82.9433354770422 54.8349897283706,82.9431322781249 54.8348650421076,82.9430405601344 54.8347250412221,82.9430442432271 54.834595025183,82.943094728546 54.834471941567,82.9425807125405 54.8343138310835,82.9423387064029 54.8342922564047,82.9413497511066 54.8342800462696,82.9409905148245 54.8342470374961,82.9406581381694 54.8341749665223,82.9384934678292 54.833490570417,82.938362852787 54.833387144263,82.938318835338 54.8332625565281,82.9383542289602 54.833125706185,82.9384471147606 54.8329989445838,82.938716968672 54.8328297560306,82.9382513718602 54.8326855571536,82.9380928192125 54.8327605282164,82.9379164799223 54.8328004713345,82.9376603702348 54.8328274794826,82.9360448400278 54.8328499345192,82.9354733318441 54.8328377756876,82.9350833731792 54.8328044552961,82.9347757001944 54.8327389527074,82.9344637152962 54.8326332998087,82.9335098841275 54.8329567768609,82.9330779741389 54.8330677580739,82.9326102213705 54.833253812607,82.9295479543985 54.8326664133816,82.9287545623395 54.8332353934534,82.9279052950699 54.8337614225461,82.9272697370064 54.8379609242879,82.9278202246125 54.8411529403686,82.9272551842988 54.8438348477665,82.9270514463924 54.8445204650501,82.9270495599303 54.8445484481259,82.9261242053561 54.8475495074341,82.9264492158259 54.8530514558734,82.9265209912171 54.8552336677483,82.9264843399535 54.8579319096258,82.9264505632988 54.8579855820262,82.9264015152843 54.8580284475046,82.9257694606504 54.8582943262096,82.9256962479547 54.8583581844084,82.9256460321304 54.8584418462519,82.9256333658849 54.8585423643313,82.9256646272567 54.8586422616805,82.9267474565002 54.8609451578974,82.9268104284017 54.8611311873301,82.9268490559589 54.861323368586,82.9271062436247 54.8639254550311,82.9271211556584 54.8639925613996,82.9271642747921 54.8640382639781,82.9270914214225 54.8641350457379,82.9270620465127 54.864197860698,82.9270509972347 54.8642666209949,82.9272552741303 54.8653474864332,82.9272987525901 54.8670594307286,82.9273274986792 54.8675627383467,82.9293040617988 54.8674460621093,82.9296148788871 54.8673944701165,82.9299694439298 54.8673594723042,82.9330277583146 54.8671756428236,82.9334712565703 54.8671581179784,82.9413438222258 54.8666001105177,82.9413455290248 54.8689743544859,82.9413545121777 54.8694179330331,82.9413660106133 54.8699781759466,82.9414197298673 54.8726054448882,82.9414277248733 54.8727209173564,82.9414617710226 54.872780927761,82.9415127054992 54.8728255349203,82.9416427815523 54.8728819269827,82.9418333142241 54.8729031709014,82.9421444906385 54.872920331431,82.9561443750154 54.8727438670824,82.9664891043327 54.8726647835121,82.9764935518204 54.8726634912956,82.9764929229997 54.8715961580162,82.9786972988754 54.8715871122601,82.9786967598863 54.8706148625608,82.9812988199382 54.8705911879443,82.9812863333558 54.8689829355879,82.9855287171166 54.8689151655099,82.9905294586402 54.8688482224148,82.9906262970278 54.8733992726612,82.9908849219982 54.8734226871902,82.991257543178 54.8734902946279,82.9920898322887 54.8736411187631,82.9925285694735 54.8736917207026,82.9930214750699 54.8737085707725,82.9947218062397 54.873676214497,82.9974977801307 54.8734730309658,82.9977230776039 54.8736495438095,83.0008816439744 54.877497435072,83.0009096714113 54.8775158340241,83.0037419696706 54.8799917602068,83.0050939341732 54.8808622879871,83.0051474737641 54.8808198602065,83.00528770078 54.8807520066716,83.0071623051149 54.8800636459974,83.0072725284002 54.8800331552751,83.0076773990988 54.8803847274057,83.0084428535524 54.8800921728895,83.0085170543948 54.88006845216,83.0088619176324 54.880025196676,83.0090505638421 54.8799846801472,83.011420050067 54.8793027147041,83.0116542408616 54.8795704686537,83.0127734518741 54.8792480887522,83.0134551833432 54.8801550663466,83.0137996872546 54.8805105133086,83.0139777333439 54.8806872537248,83.0141580252215 54.8808659054572,83.0144395572315 54.8813245980335,83.0148636518771 54.8823158129976,83.0151277565707 54.8827628103611,83.0182430241445 54.887255659416,83.0185128780558 54.8877473476316,83.0212838213812 54.8932506839448,83.0215658923804 54.8938114221888,83.0218693432834 54.8946295260066,83.0239756231301 54.9005146205622,83.0246269017111 54.9023332795265,83.0251022003279 54.9033791907459,83.0265160587536 54.905442526048,83.0269080835436 54.9061829251705,83.0280623288521 54.9077893316619,83.0292645441969 54.9092763302598,83.0324169121919 54.9131749865801,83.0337536053347 54.9146375178744,83.0340340593664 54.9149002866298,83.0343278982958 54.9151466856412,83.0347062686935 54.91539168903,83.0352018692357 54.9157320579643,83.0354501635803 54.9159228429936,83.03560413482 54.9161710428945,83.036269696614 54.9177818524765,83.0363262904769 54.9179297744141,83.0364313035336 54.9180628262474,83.0365866222462 54.9182090949845,83.0367932347615 54.918397080251,83.0369857437269 54.9185567198921,83.037120221525 54.9187815153893,83.0373567479393 54.9195713874499,83.0384808098543 54.9237847746358,83.038589056846 54.924222484405,83.0388915196022 54.9248413820951,83.0389728171354 54.9249958856384,83.039433113887 54.9255695516387,83.0398412185206 54.9268243820076,83.0399501841645 54.9280065988583,83.0399359009515 54.928205326394,83.0398522677986 54.9287454990073,83.0398117537792 54.9289163499914,83.0394113746571 54.9297665164093,83.0393927795307 54.9298803798447,83.0393978100963 54.9299795326462,83.039515399567 54.9301193578109,83.0395322878944 54.9302040062533,83.0395003078702 54.9307929273752,83.0394594345248 54.9309568017893,83.0394041881348 54.9310782490739,83.0391362206856 54.9313804463143,83.0390547434893 54.9314740211907,83.0388173187597 54.932130277927,83.0388129170149 54.9322932178733,83.0388003406009 54.9330166591342,83.0387942320569 54.9331373260329,83.0387619825382 54.9332300710464,83.0379436173144 54.9348174898217,83.0379005880123 54.9349387706227,83.0378807352445 54.9350383238238,83.0377163435475 54.9366573576715,83.0376529224884 54.9368569197755,83.0371368403577 54.9383400062287,83.0370690175538 54.9384616892405,83.0368063501647 54.9388632715291,83.0367158898156 54.9390276806998,83.0366110564219 54.9393910194866,83.0365537439068 54.9394700236938,83.0357590043749 54.9400717096889,83.0356768085264 54.9401510221711,83.0356070094289 54.940230231293,83.035428693845 54.9406018154551,83.0353842272384 54.9406946980588,83.0348949149032 54.9412487383322,83.0308255466661 54.9405717833674,83.0298390168211 54.9414058104826,83.0268749357096 54.9411288697836,83.0266570942532 54.9410910463577,83.0220080431633 54.9403879266436,83.0209588109114 54.9401971028063,83.0039578348334 54.9396224069417,83.0029601658788 54.9394602707334,83.0028862345309 54.9394554200539,83.0016793479467 54.9395181176224,82.9993123770046 54.939505320102,82.9975625486627 54.9395122348917,82.9958104745325 54.9394047458982,82.9928801700757 54.9392787310713,82.9907442458247 54.9389709167809,82.9867280578524 54.9389631246367,82.97817564719 54.9385871389829,82.9588944774262 54.9378918710457,82.955727287229 54.9376459725456,82.9372170516421 54.9368142413327,82.9366999813645 54.9339197424768,82.9366861473091 54.9337101533903,82.9364435123509 54.9326403598212,82.9361909959245 54.9311831796455,82.9251737877855 54.9273584305635,82.9224316803807 54.9267099421089,82.9220249232201 54.926500057353,82.9213396883214 54.9269407831041,82.9212906403069 54.9270461890394,82.9182846977031 54.9289857741265,82.9174705545611 54.9294613649424,82.9172518147894 54.9295772422521,82.9170642465581 54.9296503299515,82.9168548492654 54.9297075199514,82.9166041294696 54.9297621807146,82.9163467621407 54.9297964533365,82.916042502754 54.9298271128561,82.9139599384308 54.9299904750539,82.9089019742236 54.9304278076183,82.907643344679 54.9305759411395,82.9054738234363 54.930704925249,82.9000263497219 54.931186018393,82.8925565886398 54.9318119315215,82.892478075884 54.9318252992309,82.8922055270268 54.9318925506128,82.8878476199205 54.9322275671413,82.88627008845 54.9322534764839,82.8857144804468 54.9322626634579,82.8854799303261 54.9322832567236,82.8776300920474 54.9327637116504,82.8775286722518 54.9327712985497,82.8773734433707 54.9328036073702,82.8772446249589 54.9328526382783,82.877192612504 54.9329164299808,82.8771809344053 54.9330032918208,82.8771518289901 54.933346505218,82.8771202981236 54.9334345531754,82.8770221122631 54.9335072725915,82.8768777529969 54.933558212232,82.8747020333788 54.9341282982747,82.874683707747 54.9340357101624,82.8746498412608 54.9339364125296,82.8745980983004 54.9338610617715,82.8744964988418 54.9337937104606,82.8743479174938 54.9337238817411,82.8739092701405 54.9335803015393,82.873902892102 54.9335421097387,82.8737403868671 54.9322976049074,82.8736183956515 54.9316107959907,82.8722128017265 54.9309451370499,82.8711087722423 54.9301648821783,82.8710504715804 54.9301020667962,82.8697610298215 54.9291158472764,82.8697221327697 54.9290784254807,82.8697063224207 54.9290465782148,82.8694275751881 54.9284213446927,82.8694771621918 54.9278218071779,82.8660435316813 54.9278324404652,82.8657732286123 54.928160574071,82.8657094482271 54.9285041901123,82.8650980548447 54.9285951908346,82.8652133086957 54.9288523970947,82.8641797969613 54.9291840838956,82.8635889749989 54.9295508666443,82.86377241098 54.9298853865251,82.8640624769852 54.9304684798728,82.8625398325786 54.9307542167862,82.8626071163934 54.9308765937343,82.8629387743963 54.9314806276823,82.8629986021942 54.9315615571163,82.8630677724711 54.9316260218359,82.8631942552631 54.9316944606486,82.8632036875736 54.9316974541988,82.8628864026152 54.9333883615688,82.8468290169116 54.9345452517983,82.8467673924831 54.9346042411605,82.8395243661788 54.9351236844335,82.8393905172014 54.9351444310598,82.8392872109438 54.9351882982691,82.8392156152156 54.9352519314418,82.8369469199656 54.9382194065445,82.8337668838598 54.9414808891025,82.8332677798879 54.9419616985485,82.8331306071441 54.9420463736668,82.8323687459516 54.9423220180636,82.8322556480573 54.9424118007425,82.8317831342179 54.943161994267,82.8317846613539 54.9432486791837,82.8316408410769 54.9433131251703,82.8300923251901 54.9440048939582,82.8299706034691 54.943891896066,82.8298356765134 54.9437720353976,82.827709543899 54.9448574244386,82.8238393321604 54.9469931343658,82.8232291065879 54.9473299340385,82.8231887722316 54.9473512934815,82.8225129696434 54.9477101716992,82.8224671555639 54.9477365353983,82.8223289946732 54.947725339857,82.8221968524949 54.9477395277544,82.8220605780663 54.9477813691247,82.8205108943697 54.948537653412,82.8198879127201 54.9486931493524,82.8191845318527 54.9489869597144,82.8176340396723 54.9499269320825,82.8170768147016 54.9501781207567,82.8168374136783 54.9502621595006,82.8102042536204 54.9547854442511,82.8061128766589 54.9575149335337,82.80393652822 54.958985807708,82.8030032684714 54.9585287732502,82.8021444790597 54.9589896244731,82.8020673137768 54.9590137629253,82.8019698465685 54.9590262963467,82.8018773200942 54.9590210869828,82.8014836783368 54.9589207679111,82.8014119029455 54.9589218510489,82.8013412055327 54.9589374275995,82.8012886540886 54.9589608955698,82.8007465208146 54.9593555680417,82.80067043351 54.9594063202058,82.8001579446404 54.9597479672519,82.7999811561925 54.9599004283719,82.7998960857351 54.9600686713315,82.7998279934366 54.9605926337788,82.7980247153353 54.9617050578248,82.7938443153291 54.96361527732,82.7906529604507 54.9653724505173,82.7865251118887 54.9678583946562,82.7863153552698 54.9680278418825,82.7765117710796 54.9738434293431,82.7734462701726 54.9758857260116,82.7674439969387 54.9796000762886,82.7673041292489 54.9796888477779,82.762198105174 54.9829297491167,82.7561791232758 54.9867598303463,82.7507523108129 54.9885144963879,82.7520408542565 54.9911738721697,82.7523551747744 54.9916841841683,82.7523955091306 54.9917477794525,82.7528471820555 54.9924731399271,82.7581874867565 54.9972321585879,82.7584720730385 54.9974510523445,82.7644834192568 55.0027389214354,82.7770908251118 55.0132987131325,82.7780848109736 55.0142931689784,82.7784150316721 55.0147953064994,82.7788720944886 55.0156898569738,82.778868591059 55.0157937941215,82.7788214295066 55.0158886146441,82.778734113261 55.0159958475776,82.7786256866062 55.0160915432002,82.7784043417202 55.0161830152288,82.7791320669319 55.0167147437669,82.77970618023 55.0178489439407,82.7772894426211 55.0208850453531,82.7775053077839 55.0224076702671,82.7777741735484 55.0227926559948,82.778531632996 55.0226180842731,82.7812429281865 55.0229128989067,82.7871355171242 55.0227447647132,82.7920469661086 55.0270632983267,82.7921129024505 55.0271160760385,82.7922147714037 55.0271631897421,82.7923847326554 55.02721200257,82.7924745641838 55.0272474793664,82.7928437717656 55.0274466946402,82.792501783137 55.0275815981919,82.791486866529 55.0281458711414,82.7914451846998 55.0281831492278,82.7914344049164 55.0282265544699,82.7914463525096 55.0282768591815,82.7914912682739 55.0283465751258,82.7931388683365 55.0299274056716,82.7936154245947 55.030602906857,82.7946678907815 55.0316017730696,82.7964982081729 55.0309059519357,82.8046557194365 55.0367373985273)),((82.9787077193327 55.1550160072868,82.9703274258787 55.1529353521526,82.9584325637071 55.1500425699936,82.9553282555798 55.1491731441705,82.9529740407147 55.1492486043274,82.9527849453474 55.1492707803463,82.9526314232653 55.1493053276847,82.9494126697708 55.1501323502076,82.945238288477 55.1539059137476,82.9438570388962 55.1553182647826,82.9429668084496 55.1561056940844,82.9414717423222 55.1585900850946,82.9427303718668 55.1602326430893,82.9463741183223 55.1602132444051,82.9464709567099 55.1601980025752,82.9465589017762 55.1601686479233,82.9504019843932 55.1578425309899,82.9517266401112 55.1584354535022,82.9522687733851 55.1586979624718,82.9535170723039 55.1593976187015,82.9524655942639 55.1600146896052,82.9527464076217 55.1601716244449,82.9508559929378 55.1612808251579,82.9561203001658 55.1642213355692,82.9520667422777 55.1665895660541,82.9352430936367 55.1766579395493,82.9340355782318 55.1774758796701,82.9331104033207 55.1782912894999,82.9282269817732 55.1849454175237,82.9282044340595 55.1849760874083,82.9301216185389 55.1850407607833,82.9301374288879 55.1850726614895,82.9316851362909 55.1882852702865,82.93638997276 55.1918662631937,82.9382074442428 55.1926789685354,82.9371160810041 55.1937919823363,82.9357702250455 55.1954011978282,82.9357373467061 55.1956271103989,82.9358349037459 55.1958342043419,82.9371416829897 55.1973217727351,82.937311734073 55.1974418504541,82.9375451163838 55.1975176807314,82.9392439204176 55.1978168474558,82.95574615185 55.200084391499,82.9665696832137 55.1964225626646,82.9725474324404 55.1972859339264,82.9729573337045 55.1973882205697,82.9733691214308 55.1975328057526,82.9736219073517 55.1976744166889,82.9738568167985 55.1978267427349,82.9742496500723 55.1979883481892,82.9755838279322 55.1989201302983,82.9763523366578 55.1988062606597,82.9772434654196 55.1987777034773,82.9780761138565 55.1987642195582,82.9790609369025 55.1987626301986,82.9811575149441 55.1987720638159,82.982093200144 55.1988002108454,82.9828272135627 55.1988315878385,82.9834082438884 55.1988366122566,82.9839865792683 55.1987838045647,82.9847515845643 55.1986647562876,82.9854422093547 55.1984660853515,82.986113250872 55.1982417782647,82.9867500665769 55.1979876816706,82.9891259308403 55.197077001746,82.9896969000349 55.1968799123238,82.9990862710476 55.1910331319885,83.0043325221384 55.1862953316855,83.0045330261098 55.1859720765151,83.0045688688896 55.1855687090553,83.0037598461447 55.1834119444811,83.0037808667224 55.1829958311943,83.0039982590211 55.1826108981723,83.0076976111927 55.1792057331062,83.0079733041534 55.1787873701941,83.0080991581247 55.1783396103188,83.0080572068009 55.1778734299538,83.0070053694347 55.1761292063256,83.0068128604694 55.1752516280942,83.0068666695549 55.1744760682159,83.0070342053553 55.1741251683265,83.0074682713006 55.1739037509588,83.0087368721449 55.1734181777496,83.0089830105327 55.1732845350623,83.0090449044558 55.1730810176794,83.0087239364048 55.1715934674682,83.0086565627585 55.1708559051753,83.0087901422412 55.1701933906276,83.0105389824363 55.1671776379754,83.0130063850272 55.1586019403297,83.0092605899555 55.1562253827985,82.9968573711646 55.1573383885212,82.9967507411404 55.1565177255919,82.9963105666512 55.1529648661142,82.9927774028072 55.1531554487874,82.9920627929987 55.1533983851975,82.9912164901695 55.1536166828056,82.9903965978097 55.1537937632231,82.9903022747049 55.1538091614831,82.9898440440784 55.1538840995971,82.9887929253645 55.1540080551409,82.9874977343879 55.154094541493,82.9844060026745 55.154275931251,82.9814661760757 55.1544495185265,82.9811022685541 55.154482316274,82.9806571533308 55.1545456533189,82.9801641579029 55.1546329084024,82.9796968542921 55.1547432601464,82.9792057453263 55.1548678802605,82.9787077193327 55.1550160072868)))"},"adm_divs":[],"attributes":{"area":4951911635480,"length":null,"houses_count":null,"abbreviation":null,"city_description":"City"}}]}}';
                latlng = new DG.latLng(54.98017192278902, 82.89799869060518);
                clock = sinon.useFakeTimers();
                xhr = sinon.useFakeXMLHttpRequest();
                requests = [];
                xhr.onCreate = function (req) { requests.push(req); };

                map.fire('click', {latlng: latlng});
                map.geoclicker.getController()._hasCatalogKey = true;
            });

            after(function () {
                clock.restore();
                xhr.restore();
                requests = xhr = clock = null;
            });

            it('should send request', function() {
                clock.tick(300);
                expect(requests.some(function (request) {
                    return request.url.indexOf('items/geocode') !== -1;
                })).to.be(true);
            });

                it('should request url contain lat and lng', function() {
                var geoSearchRequstUrl = '';

                requests.forEach(function (request) {
                    if (request.url.indexOf('items/geocode') !== -1) {
                        geoSearchRequstUrl = request.url;
                    }
                });

                expect(geoSearchRequstUrl).to.contain(latlng.lat);
                expect(geoSearchRequstUrl).to.contain(latlng.lng);
            });

            it('should open popup', function() {
                var popup = mapContainer.getElementsByClassName('leaflet-popup');
                expect(popup.length).to.be(1);
            });
        });
    });
});


================================================
FILE: src/DGLabel/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>
    <title>DGLabel demo</title>
    <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>
    <style type="text/css">
        html,body { height: 100%; margin: 0; padding: 0; }
        #map { width: 100%; height: 100%; }
    </style>
</head>
<body>
    <div id="map"></div>
    <script type="text/javascript">
        DG.then(function () {
            var map = new DG.Map('map', {
                center: new DG.LatLng(54.980206086231, 82.898068362003),
                zoom: 12,
                key: DG.config.key || 'Your API access key'
            });

            var markerStatic = DG.marker([54.950206086231, 82.898068362003], {
                                riseOnHover : true,
                                draggable : true
                            });
            markerStatic.addTo(map);
            markerStatic.bindLabel( 'Многострочная<br/>подсказка!');

            var marker = DG.marker([54.950206086231, 82.938068362003], {
                                riseOnHover : true,
                                label : 'Подсказка'
                            });
            marker.addTo(map);

            var standaloneLabel = DG.label('Статический тултип');
            standaloneLabel.setPosition(new DG.LatLng(54.980206086231, 82.898068362003));
            map.addLayer(standaloneLabel);
        });
    </script>
</body>
</html>


================================================
FILE: src/DGLabel/skin/basic/less/dg-label.less
================================================
.dg-label {
    position: absolute;
    top: 0;
    left: 0;
    max-width: none;
    max-height: none;
    width: 300px;
    user-select: none;
}

.dg-label__content {
    display: inline-block;
    overflow: hidden;
    padding: 3px 7px;
    min-width: 30px;
    max-width: 300px;
    width: auto;
    border-width: 1px;
    border-style: solid;
    border-radius: 2px;
    vertical-align: top;
    font-size: 12px;
}

.dg-label_name_location-error {
    .leaflet-top & {
        top: 5px;
    }
    .leaflet-right & {
        right: 40px;
        left: auto;
        text-align: right;
    }
    .leaflet-bottom & {
        top: 4px;
    }
    .leaflet-left & {
        left: 40px;
    }
}


================================================
FILE: src/DGLabel/skin/dark/less/dg-label.less
================================================
.dg-label__content {
    border-color: #323232;
    border-color: rgba(50, 50, 50, .85);
    background: #323232;
    background: rgba(50, 50, 50, .85);
    color: #ffd26e;
}


================================================
FILE: src/DGLabel/skin/light/less/dg-label.less
================================================
.dg-label__content {
    border-color: #bebdb5;
    border-color: rgba(151, 151, 151, .6);
    background: #fff;
    background: rgba(255, 255, 255, .85);
    color: #727170;
}


================================================
FILE: src/DGLabel/src/DGLabel.Layer.js
================================================


================================================
FILE: src/DGLabel/src/DGLabel.js
================================================
DG.Label = DG.Layer.extend({

    options: {
        offset: new DG.Point(12, 15),
        className: 'dg-label',
        zIndexOffset: 0,
        textDirection: 'auto' // 'auto' | 'ltr' | 'rtl
    },

    _typeOfString : Object.prototype.toString.call('s'),
    _defaultZIndex: 100,

    initialize: function(content, options) {
        DG.Util.setOptions(this, options);

        this._animated = DG.Browser.any3d;
        this._content = content;
    },

    onAdd: function(map) {
        this._map = map;

        if (!this._el) {
            this._initDOM();
        }

        this._visible = true;

        this
            .setContent(this._content)
            ._onViewReset();

        map
            .on('viewreset', this._onViewReset, this)
            .on('zoomanim', this._onZoomAnimation, this);
    },

    onRemove: function(map) {
        map
            .off('viewreset', this._onViewReset, this)
            .off('zoomanim', this._onZoomAnimation, this);

        this._visible = false;

        this._el.removeChild(this._container);
        DG.Util.falseFn(this._container.offsetWidth); // we need reflow here
        this._container = null;

        map.getPanes().tooltipPane.removeChild(this._el);
        this._el = null;
    },

    _initDOM: function() {
        this._el = DG.DomUtil.create(
            'div',
            this.options.className + ' leaflet-zoom-' + (this._animated ? 'animated' : 'hide'),
            this._map.getPanes().tooltipPane);
        this._el.style.zIndex = this._defaultZIndex + this.options.zIndexOffset;

        this._container = DG.DomUtil.create('div', this.options.className + '__content', this._el);
        this._container.setAttribute('dir', this.options.textDirection);

        DG.DomEvent
            .disableClickPropagation(this._el)
            .on(this._container, 'mousewheel', DG.DomEvent.stopPropagation)
            .on(this._container, 'contextmenu', DG.DomEvent.stopPropagation);
    },

    _onViewReset: function() {
        if (this._visible && this._latlng) {
            DG.DomUtil.setPosition(this._el, this._map.latLngToLayerPoint(this._latlng).add(this.options.offset), DG.Browser.ie);
        }
    },

    _onZoomAnimation: function(opt) {
        if (this._latlng) {
            DG.DomUtil.setPosition(this._el, this._map._latLngToNewLayerPoint(this._latlng, opt.zoom, opt.center).add(this.options.offset));
        }
    },

    setOffset: function(point) {
        if (point instanceof DG.Point) {
            this.options.offset = point;
            this._onViewReset();
        }
        return this;
    },

    setZIndexOffset: function(zIndex) {
        if (!isNaN(+zIndex)) {
            this.options.zIndexOffset = +zIndex;
            if (this._visible) {
                this._el.style.zIndex = this._defaultZIndex + this.options.zIndexOffset;
            }
        }
        return this;
    },

    setContent: function(content) {
        if (Object.prototype.toString.call(content) !== this._typeOfString) {
            return this;
        }
        this._content = content;
        if (this._visible) {
            this._container.innerHTML = content;
        }
        return this;
    },

    setPosition: function(latlng) {
        if (!(latlng instanceof DG.LatLng)) {
            return this;
        }

        this._latlng = latlng;
        this._onViewReset();
        return this;
    }
});

DG.label = function(content, options) {
    return new DG.Label(content, options);
};


================================================
FILE: src/DGLabel/src/Entrance.DGLabel.js
================================================
DG.Entrance.include({
    bindLabel: function(content, options) {

        if (!this._label) {
            this._label = DG.label(content, options);
            this.on(this._labelEvents, this);
        } else {
            this._label.setContent(content);

            if (this._label.options.offset !== options.offset) {
                this._label.setOffset(options.offset);
            }
        }
        return this;
    },

    unbindLabel: function() {
        if (this._label) {
            this.off(this._labelEvents, this);
            this._map.removeLayer(this._label);
            this._label = null;
        }
        return this;
    },

    getLabel: function() {
        return this._label ? this._label : null;
    },

    _labelEvents : {
        mouseover: function(event) {
            this._map.addLayer(this._label.setPosition(event.latlng));
            DG.DomEvent.stop(event);
        },
        mousemove: function(event) {
            this._label.setPosition(event.latlng);
            DG.DomEvent.stop(event);
        },
        mouseout: function() {
            this._label.remove();
        },
        remove: function() {
            this._label.remove();
        }
    }
});

DG.Entrance.addInitHook(function() {
    if (typeof this.options.label !== 'undefined') {
        this.bindLabel(this.options.label);
    }
});


================================================
FILE: src/DGLabel/src/Marker.DGLabel.js
================================================
DG.Marker.include({

    bindLabel: function(content, options) {
        if (this._label) {
            this._label.setContent(content);
            if (options) {
                if (this.options.offset !== options.offset) {
                    this._label.setOffset(this.options.offset = options.offset);
                }
                if (this.options.static !== options.static) {
                    this.unbindLabel().bindLabel(content, options);
                }
            }
        } else {
            options = DG.extend({
                offset: new DG.Point(5, 5)
            }, options);

            this._label = DG.label(content, options);

            this.once('remove', this._onMarkerRemove);

            if (options.static) {
                this.showLabel();
            } else {
                this
                    .on('mouseover', this._mouseOverLabel)
                    .on('mouseout', this._mouseOutLabel)
                    .on('dragstart', this._dragStartLabel)
                    .on('dragend', this._dragEndLabel);
            }

            if (typeof this._map !== 'undefined') {
                this._updateLabelZIndex();
            } else {
                this.once('add', this._updateLabelZIndex);
            }
        }
        return this;
    },

    unbindLabel: function() {
        if (this._label) {
            this
                .hideLabel()
                .off('remove', this.unbindLabel)
                .off('mouseover', this._mouseOverLabel)
                .off('mouseout', this._mouseOutLabel)
                .off('dragstart', this._dragStartLabel)
                .off('dragend', this._dragEndLabel)
                .off('move', this._updatePosition)
                .off('add', this._updateLabelZIndex);

            this._label = null;
        }
        return this;
    },

    _onMarkerRemove: function() {
        if (this._label) {
            var content = this._label._content;
            this.once('add', function() {
                if (this._label) { return; } // new label added after removing marker
                this.bindLabel(content);
            });
            this.unbindLabel();
        }
    },

    getLabel: function() {
        return this._label ? this._label : null;
    },

    _originalUpdateZIndex: DG.Marker.prototype._updateZIndex,
    _updateZIndex: function(offset) {
        if (!this._zIndex) {
            this._zIndex = 0;
        }
        this._originalUpdateZIndex(offset);
        this._updateLabelZIndex();
        return this;
    },

    _updateLabelZIndex: function() {
        if (this._label && this._icon) {
            this._label.setZIndexOffset(this._icon.style.zIndex);
        }
        return this;
    },

    showLabel : function() {
        if (this._label) {
            this
                .on('move', this._updatePosition)
                ._map.addLayer(this._label.setPosition(this.getLatLng()));
        }

        return this;
    },

    hideLabel : function() {
        if (this._label) {
            this
                .off('move', this._updatePosition)
                ._map.removeLayer(this._label);
        }
        return this;
    },

    _updatePosition : function() {
        this._label.setPosition(this.getLatLng());
    },

    _dragStartLabel: function() {
        this._label.isMarkerDragging = true;

        this.hideLabel();
    },

    _dragEndLabel: function() {
        this._label.isMarkerDragging = false;

        if (this._label.isMouseOverMarker) {
            this.showLabel();
        }
    },

    _mouseOverLabel: function() {
        this._label.isMouseOverMarker = true;

        if (!this._label.isMarkerDragging) {
            this.showLabel();
        }
    },

    _mouseOutLabel: function() {
        this._label.isMouseOverMarker = false;

        this.hideLabel();
    }
});

DG.Marker.addInitHook(function() {
    if (typeof this.options.label !== 'undefined') {
        this.bindLabel(this.options.label);
    }
});


================================================
FILE: src/DGLabel/src/Path.DGLabel.js
================================================
DG.Path.include({
    bindLabel: function(content, options) {

        if (!this._label) {
            this._label = DG.label(content, options);
            this.on(this._labelEvents, this);
        } else {
            this._label.setContent(content);

            if (this._label.options.offset !== options.offset) {
                this._label.setOffset(options.offset);
            }
        }
        return this;
    },

    unbindLabel: function() {
        if (this._label) {
            this.off(this._labelEvents, this);
            this._map.removeLayer(this._label);
            this._label = null;
        }
        return this;
    },

    getLabel: function() {
        return this._label ? this._label : null;
    },

    _labelEvents : {
        mouseover: function(event) {
            this._map.addLayer(this._label.setPosition(event.latlng));
            DG.DomEvent.stop(event);
        },
        mousemove: function(event) {
            this._label.setPosition(event.latlng);
            DG.DomEvent.stop(event);
        },
        mouseout: function(event) {
            this._map.removeLayer(this._label);
            DG.DomEvent.stop(event);
        },
        remove: function() {
            this._map.removeLayer(this._label);
        }
    }
});

DG.Path.addInitHook(function() {
    if (typeof this.options.label !== 'undefined') {
        this.bindLabel(this.options.label);
    }
});


================================================
FILE: src/DGLabel/test/DGLabelSpec.js
================================================
describe('DG.Label', function () {
    var map,
        mapContainer = document.createElement("div");

    after(function() {
        mapContainer = null;
    });

    beforeEach(function () {
        map = new DG.Map(mapContainer, {
            center: new DG.LatLng(69.349552990994837, 87.75222519148015),
            zoom: 17,
            key: window.__karma__.config.secretKey,
        });
    });

    afterEach(function () {
        map && map.remove();
        map = null;
    });

    describe('"DG.Label" class', function(){
        var label = DG.label();
        it('it should have "onAdd()" public method', function(){
            expect(label.onAdd).to.be.a('function');
        });
        it('it should have "onRemove()" public method', function(){
            expect(label.onRemove).to.be.a('function');
        });
        it('it should properly merge options object passed to constructor', function(){
            var labelWithOptions = DG.label('', { className: "test-class" });
            expect(labelWithOptions.options.className).to.eql('test-class');
        });
        describe('#setContent and #setPosition', function(){
            it('should return "DG.Label" instance', function(){
                expect(label.setContent('ra-ta-ta')).to.be.a(DG.Label);
                expect(label.setPosition( new DG.LatLng(54.980206086231, 82.898068362003) )).to.be.a(DG.Label);

                expect(label.setContent( null )).to.be.a(DG.Label);
                expect(label.setPosition( null )).to.be.a(DG.Label);
            });
        });
    });

    describe('"DG.label()" factory', function(){
        it(' should return "DG.Label" instance', function(){
            var label = DG.label();
            expect(label).to.be.a(DG.Label);
        });
    });

    describe('mixins into "DG.Marker"', function(){
        it('#bindLabel should return "DG.Marker" instance', function(){
            var marker = DG.marker([54.950206086231, 82.898068362003]).addTo(map);

            expect(marker.bindLabel()).to.be.a(DG.Marker);
        });
        it('#unbindLabel should return "DG.Marker" instance', function(){
            var marker = DG.marker([54.950206086231, 82.898068362003]).addTo(map),
                markerWithLabel = DG.marker([54.950206086231, 82.898068362003]).addTo(map).bindLabel('ra-ta-ta');

            expect(marker.unbindLabel()).to.be.a(DG.Marker);
            expect(markerWithLabel.unbindLabel()).to.be.a(DG.Marker);
        });
        it('#showLabel should return "DG.Marker" instance', function(){
            var marker = DG.marker([54.950206086231, 82.898068362003]).addTo(map),
                markerWithLabel = DG.marker([54.950206086231, 82.898068362003]).addTo(map).bindLabel('ra-ta-ta');

            expect(marker.showLabel()).to.be.a(DG.Marker);
            expect(markerWithLabel.showLabel()).to.be.a(DG.Marker);
        });
        it('#hideLabel should return "DG.Marker" instance', function(){
            var marker = DG.marker([54.950206086231, 82.898068362003]).addTo(map),
                markerWithLabel = DG.marker([54.950206086231, 82.898068362003]).addTo(map).bindLabel('ra-ta-ta');

            expect(marker.hideLabel()).to.be.a(DG.Marker);
            expect(markerWithLabel.hideLabel()).to.be.a(DG.Marker);
        });
        it('#getLabel should return "DG.Label" instance after #bindLabel call', function(){
            var markerWithLabel = DG.marker([54.950206086231, 82.898068362003])
                                        .addTo(map)
                                        .bindLabel('ra-ta-ta');

            expect(markerWithLabel.getLabel()).to.be.a(DG.Label);
        });
        it('#getLabel should return null after #unbindLabel call and before #bindLabel call', function(){
            var marker = DG.marker([54.950206086231, 82.898068362003]).addTo(map),
                markerWithLabel = DG.marker([54.950206086231, 82.898068362003]).addTo(map).bindLabel('ra-ta-ta');

            expect(marker.getLabel()).to.be(null);
            expect(markerWithLabel.unbindLabel().getLabel()).to.be(null);
        });
    });

    describe('mixins into "DG.Path"', function(){
        it('#bindLabel should return "DG.Path" instance', function(){
            var path = DG.circle([55.0, 83.0], 900).addTo(map);

            expect(path.bindLabel()).to.be.a(DG.Path);
        });
        it('#unbindLabel should return "DG.Path" instance', function(){
            var path = DG.circle([55.0, 83.0], 900).addTo(map),
                pathWithLabel = DG.circle([55.0, 83.0], 900).addTo(map).bindLabel('ra-ta-ta');

            expect(path.unbindLabel()).to.be.a(DG.Path);
            expect(pathWithLabel.unbindLabel()).to.be.a(DG.Path);
        });
        it('#getLabel should return "DG.Label" instance after #bindLabel call', function(){
            var pathWithLabel = DG.circle([55.0, 83.0], 900)
                                        .addTo(map)
                                        .bindLabel('ra-ta-ta');

            expect(pathWithLabel.getLabel()).to.be.a(DG.Label);
        });
        it('#getLabel should return null after #unbindLabel call and before #bindLabel call', function(){
            var path = DG.circle([55.0, 83.0], 900).addTo(map),
                pathWithLabel = DG.circle([55.0, 83.0], 900).addTo(map).bindLabel('ra-ta-ta');

            expect(path.getLabel()).to.be(null);
            expect(pathWithLabel.unbindLabel().getLabel()).to.be(null);
        });
    });

});


================================================
FILE: src/DGLocale/demo/index.html
================================================
<!DOCTYPE html>
<html lang="it">
<head>
    <title>DGLocale demo</title>
    <meta charset="utf-8"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>
</head>
<body>

<div id="map" style="width: 100%; height: 600px; border: 1px solid #ccc;"></div>

<script type="text/javascript">
    var map;
    DG.then(function () {

       // plugin code
       // {APP_CORE}/src/{Plugin}/{Plugin}.js
        DG.LocaleExample = DG.Control.extend({

            includes: DG.Locale,
            options: {
                position: 'topright'
            },
            statics: {
                Dictionary: {}
            },

            _container: null,

            onAdd: function (map) {
                this._container = DG.DomUtil.create('div', 'locale-example');
                this._renderTranslation();
                return this._container;
            },

            //this function will be called every time when we change language
            _renderTranslation:function () {
                this._container.innerHTML = '<h1>' + this.t("{n} people", 16700000) + ' ' + this.t("regularly use 2GIS") + '</h1>';
            }
        });

        //{APP_CORE}/src/{Plugin}/lang/it.js
        DG.LocaleExample.Dictionary.it = DG.extend({
            "{n} people" : ["{n} utente", "{n} utenti"],
            "regularly use 2GIS" : "utilizzano regolarmente 2GIS"
        }, DG.Dictionary.it);

        //{APP_CORE}/src/{Plugin}/lang/ru.js
        DG.LocaleExample.Dictionary.ru = DG.extend({
            "{n} people" : ["{n} пользователь", "{n} пользователя", "{n} пользователей"],
            "regularly use 2GIS" : "регулярно используют 2GIS"
        }, DG.Dictionary.ru);

        //{APP_CORE}/src/{Plugin}/demo/index.html
        map = new DG.Map('map', {
            center: new DG.LatLng(54.980206086231, 82.898068362003),
            zoom: 13,
            key: DG.config.key || 'Your API access key'
        });
        map.addControl(new DG.LocaleExample());
        var langMenu = DG.DomUtil.get('langMenu');
        langMenu.onchange = function() {
            map.setLang(this.options[this.selectedIndex].value);
        }
    });
</script>

Изменить язык карты: <select id="langMenu" size="1">
    <option value="ru" selected="selected">ru</option>
    <option value="it">it</option>
</select>

</body>
</html>


================================================
FILE: src/DGLocale/src/DGDictionary.js
================================================
DG.Dictionary = {};

DG.Dictionary.ru = {
    pluralRules: function(n) { // (Number)
        if (n % 10 === 1 && n % 100 !== 11) { // 1, 21
            return 0;
        }
        if ((n % 10 >= 2 && n % 10 <= 4 && (n % 10) % 1 === 0) && (n % 100 < 12 || n % 100 > 14)) { // 2, 3
            return 1;
        }

        if ((n % 10 === 0) || (n % 10 >= 5 && n % 10 <= 9 && (n % 10) % 1 === 0) || (n % 100 >= 11 && (n % 100) <= 14 && (n % 100) % 1 === 0)) { // 13, 17
            return 2;
        }
    }
};

DG.Dictionary.en = {
    pluralRules: function(n) { // (Number)
        if (n === 1) { // 1
            return 0;
        } else {
            return 1; //0, 2, 3, 4 ..
        }
    }
};

DG.Dictionary.it = {
    pluralRules: function(n) { // (Number)
        if (n === 1) { // 1
            return 0;
        } else {
            return 1; //0, 2, 3, 4 ..
        }
    }
};

DG.Dictionary.cs = {
    pluralRules: function(n) { // (Number)
        return (n === 1) ? 0 : (n >= 2 && n <= 4) ? 1 : 2;
    }
};

DG.Dictionary.es = {
    pluralRules: function(n) { // (Number)
        return (n >= 2) ? 1 : 0;
    }
};

// Stub for Arabic language, we don't have cases with plural form usage
// Actually Arabic has 6 plural forms
DG.Dictionary.ar = {
    pluralRules: function() {
        return 0;
    }
};


================================================
FILE: src/DGLocale/src/DGLocale.js
================================================
DG.Locale = {
    t: function(msg, argument) { // (String, Number) -> String
        var result,
            lang = this._map.getLang(),
            msgIsset = false,
            dictionaryMsg,
            exp;

        if (typeof this.constructor.Dictionary[lang] === 'undefined') {
            if (lang === 'ar') {
                lang = 'en';
            } else {
                lang = DG.config.defaultLang;
            }
        }
        dictionaryMsg = this.constructor.Dictionary[lang][msg];
        msgIsset = typeof dictionaryMsg !== 'undefined';
        if (!msgIsset) {
            return msg;
        }
        result = msgIsset ? dictionaryMsg : msg;

        if (argument !== undefined) {
            argument = parseInt(argument, 10);
            argument = isNaN(argument) ? 0 : argument;
            exp = this.constructor.Dictionary[lang].pluralRules(argument);
            result = dictionaryMsg[exp];
        }

        result = DG.Util.template(result, {n: argument});
        return result;
    }
};

DG.Map.include({
    setLang: function(lang) { // (String)
        if (lang && Object.prototype.toString.call(lang) === '[object String]') {
            this.options.currentLang = lang;
            this.fire('langchange', {'lang': lang});
        }
    },

    getLang: function() { // () -> String
        // If the language hasn't been set before, set it to page language or
        // default language from config
        if (!this.options.currentLang) {
            var root = document.documentElement;
            var lang = root.lang || (root.getAttributeNS && root.getAttributeNS('http://www.w3.org/XML/1998/namespace', 'lang')) || DG.config.defaultLang;

            this.options.currentLang = lang;
        }

        return this.options.currentLang;
    }
});


================================================
FILE: src/DGLocale/test/DGLocaleSpec.js
================================================
describe('DG Locale Module', function () {
	var map,
		getLangSpy,
		setLangSpy;

	beforeEach(function () {
		map = new DG.Map(document.createElement('div'), {
            center : new DG.LatLng(54.980206086231, 82.898068362003),
            zoom: 10,
            fullScreenControl: false,
            key: window.__karma__.config.secretKey,
        });
		getLangSpy = sinon.spy(map, 'getLang');
		setLangSpy = sinon.spy(map, 'setLang');
	});

	afterEach(function () {
		map.remove();
		map = null;
		getLangSpy = null;
		setLangSpy = null;
	});

	describe('getLang / setLang test cases', function () {
        //Skip this check because it often fails
		it.skip('should return default language: ru', function () {
			map.getLang();

			expect(getLangSpy.calledOnce).to.be.ok();

			expect(getLangSpy.returnValues).to.eql(['ru']);
		});

		it('should return language that was set: it', function () {
			map.setLang('it');

			getLangSpy.reset();

			map.getLang();

			expect(setLangSpy.calledOnce).to.be.ok();
			expect(getLangSpy.calledOnce).to.be.ok();
			expect(getLangSpy.returnValues).to.eql(['it']);
		});

		it('should return default language (ru) if setLang was called with invalid argument: undefined, null, etc', function () {
			getLangSpy.reset();

			map.setLang(null);
			map.getLang();

			map.setLang(undefined);
			map.getLang();

			map.setLang('');
			map.getLang();

			map.setLang(5);
			map.getLang();

			map.setLang(['it']);
			map.getLang();

			map.setLang({lang: 'it'});
			map.getLang();

			expect(getLangSpy.returnValues).to.eql(['ru', 'ru', 'ru', 'ru', 'ru', 'ru']);
		});

		it('should call langchange event when setting new lang through setLang method', function () {
			var callback = sinon.spy(function () {
				return 5;
			});
			map.on('langchange', callback);
			map.setLang('it');

			expect(setLangSpy.calledOnce).to.be.ok();
			expect(callback.calledOnce).to.be.ok();
			expect(callback.returnValues).to.eql([5]);
		});
	});

	describe('t() method test cases', function () {
		var TestPlugin,
			plugin,
            tSpy;

		beforeEach(function () {
			TestPlugin = DG.Control.extend({
			    includes: DG.Locale,
			    options: {
			        position: 'topright'
			    },
			    statics: {
					Dictionary: {}
			    },
			    onAdd: function () {
			        return DG.DomUtil.create('div', 'locale-example');
			    }
			});

			TestPlugin.Dictionary.ru = DG.extend({
				'{n} people' : ['{n} пользователь', '{n} пользователя', '{n} пользователей'],
				'regularly use 2GIS' : 'регулярно используют 2GIS'
			}, DG.Dictionary.ru);

			TestPlugin.Dictionary.it = DG.extend({
				'{n} people' : ['{n} utente', '{n} utenti'],
				'regularly use 2GIS' : 'utilizzano regolarmente 2GIS'
			}, DG.Dictionary.it);

			plugin = new TestPlugin();
			map.addControl(plugin);
			tSpy = sinon.spy(plugin, 't');
		});

		afterEach(function () {
			TestPlugin = null;
			plugin = null;
			tSpy = null;
		});

		it('should correctly get dictionary by lang', function () {
			plugin.t('{n} people', 123456);
			map.setLang('it');
			plugin.t('{n} people', 1234560);

			expect(setLangSpy.calledOnce).to.be.ok();
			expect(tSpy.calledTwice).to.be.ok();

			expect(tSpy.returnValues).to.eql(['123456 пользователей', '1234560 utenti']);
		});

		it('should return source message for call with not existing lang: uk', function () {
			map.setLang('uk');
			plugin.t('regularly use 2GIS');

			expect(TestPlugin.Dictionary).to.not.have.property('uk');
			expect(tSpy.calledOnce).to.be.ok();
			expect(tSpy.returnValues).to.eql(['регулярно используют 2GIS']);
		});

		it('should return source message for call with not existing message for lang: ru', function () {
			plugin.t('not existing message', 1);

			expect(tSpy.calledOnce).to.be.ok();
			expect(tSpy.returnValues).to.eql(['not existing message']);
		});

		it('should set second argument to 0 when it`s type is not Number', function () {
			plugin.t('{n} people', 'dds');

			expect(tSpy.calledOnce).to.be.ok();
			expect(tSpy.returnValues).to.eql(['0 пользователей']);
		});

	});

});


================================================
FILE: src/DGLocation/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset='utf-8'>
  <title>Leaflet.Control.Locate Demo</title>
  <script src="http://maps.api.2gis.dev/2.0/loader.js"></script>

</head>
<body>

  <div id="map" style="width: 100%; height: 600px; border: 1px solid #ccc;"></div>

  <script type="text/javascript">

  DG.then(function () {

    map = new DG.Map('map', {
        center: new DG.LatLng(54.980206086231, 82.898068362003),
        zoom:15,
        locationControl: true,
        key: DG.config.key || 'Your API access key'
    });

    map.locationControl.setPosition('bottomleft');

  });
  </script>

</body>
</html>


================================================
FILE: src/DGLocation/lang/ar.js
================================================
DG.Control.Location.Dictionary.ar = {
    cant_find : 'لم نستطع تحديد موقعك',
    you_are_here : 'أنت هنا',
    button_title : 'موقعي'
};


================================================
FILE: src/DGLocation/lang/cs.js
================================================
DG.Control.Location.Dictionary.cs = {
    cant_find : 'Nepodařilo se nám určit Vaši polohu',
    you_are_here : 'Jste tady',
    button_title : 'Určit Vaši polohu na mapě'
};


================================================
FILE: src/DGLocation/lang/en.js
================================================
DG.Control.Location.Dictionary.en = {
    cant_find : 'We can\'t find you',
    you_are_here : 'You are here',
    button_title : 'Show your location'
};


================================================
FILE: src/DGLocation/lang/es.js
================================================
DG.Control.Location.Dictionary.es = {
    cant_find : 'No pudimos encontrarte',
    you_are_here : 'Tú estás aquí',
    button_title : 'Encontrarte en el mapa'
};


================================================
FILE: src/DGLocation/lang/it.js
================================================
DG.Control.Location.Dictionary.it = {
    cant_find : 'Non siamo riusciti a localizzarti',
    you_are_here : 'Voi siete qui',
    button_title : 'Trova la tua posizione sulla mappa'
};


================================================
FILE: src/DGLocation/lang/ru.js
================================================
DG.Control.Location.Dictionary.ru = {
    cant_find : 'Мы не смогли Вас найти',
    you_are_here : 'Вы здесь',
    button_title : 'Найти Вас на карте'
};


================================================
FILE: src/DGLocation/skin/basic/less/dg-control-round.less
================================================
.dg-control-round__icon_name_locate {
    &:after {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        margin: auto;
        content: '';
    }

    .dg-control-round__icon_state_active&:after,
    .no-touch .dg-control-round__icon_state_active&:hover:after,
    .dg-control-round__icon_state_active&:active:after {
        .notRepeatableBg('DGRoundControl__locateIconEnabled');
    }
}

@keyframes DGLocation__locateIconRequestingAnim {
    to {
        transform: rotate(360deg);
    }
}


================================================
FILE: src/DGLocation/skin/basic/less/dg-location.less
================================================
.dg-location__pin {
    .notRepeatableBgWithSizes('DGLocation__pin');

    &_state_following {
        .notRepeatableBg('DGLocation__pinFollowing');
    }
}


================================================
FILE: src/DGLocation/skin/dark/less/dg-control-round.less
================================================
.dg-control-round__icon_name_locate {
    &:after {
        .notRepeatableBgWithSizes('DGRoundControl__locateIcon_dark');
    }

    .no-touch &:hover:after,
    &:active:after {
        .notRepeatableBg('DGRoundControl__locateIconHover_dark');
    }

    .dg-control-round__icon_state_requesting&:after,
    .no-touch .dg-control-round__icon_state_requesting&:hover:after,
    .dg-control-round__icon_state_requesting&:active:after {
        .notRepeatableBgWithSizes('DGRoundControl__locateIconRequesting_dark');
        animation: DGLocation__locateIconRequestingAnim 1s linear infinite;
        image-rendering: optimizeQuality;
    }
}


================================================
FILE: src/DGLocation/skin/light/less/dg-control-round.less
================================================
.dg-control-round__icon_name_locate {
    &:after {
        .notRepeatableBgWithSizes('DGRoundControl__locateIcon_light');
    }

    .no-touch &:hover:after,
    &:active:after {
        .notRepeatableBg('DGRoundControl__locateIconHover_light');
    }

    .dg-control-round__icon_state_requesting&:after,
    .no-touch .dg-control-round__icon_state_requesting&:hover:after,
    .dg-control-round__icon_state_requesting&:active:after {
        .notRepeatableBgWithSizes('DGRoundControl__locateIconRequesting_light');
        animation: DGLocation__locateIconRequestingAnim 1s linear infinite;
        image-rendering: optimizeQuality;
    }
}


================================================
FILE: src/DGLocation/src/DGLocation.js
================================================
DG.Control.Location = DG.RoundControl.extend({

    statics: {
        Dictionary: {}
    },

    options: {
        iconClass: 'locate',
        position: DG.Browser.mobile ? 'bottomright' : 'topleft',
        drawCircle: true,
        follow: true,  // follow with zoom and pan the user's location
        stopFollowingOnDrag: false, // if follow is true, stop following when map is dragged
        metric: true,
        onLocationError: function(/*err*/) {
            // this event is called in case of any location error
            // that is not a time out error.
            // console.log(err.message);
        },
        onLocationOutsideMapBounds: function(/*context*/) {
            // this event is repeatedly called when the location changes
            // console.log(context.t('outsideMapBoundsMsg'));
        },
        locateOptions: {}
    },

    initialize: function(options) {
        DG.Util.setOptions(this, options);

        if (!navigator.geolocation) {
            this._disable = true;
            return;
        }

        this._event = undefined;

        this._locateOptions = {
            watch: true,  // if you overwrite this, visualization cannot be updated
            setView: true,
            maximumAge: Infinity,
            maxZoom: Infinity
        };
        DG.extend(this._locateOptions, this.options.locateOptions);

        this._resetVariables();

        this.on({
            'click': this._handleLocate,
            'add': this._initLocate
        });
    },

    _initLocate: function() {
        this._layer = new DG.LayerGroup();
        this._layer.addTo(this._map);

        // event hooks
        this._map.on({
            'locationfound': this._onLocationFound,
            'locationerror': this._onLocationError
        }, this);
    },

    _handleLocate: function() {
        if (this._active && (!this._event ||
            (this._map.getBounds().contains(this._event.latlng) ||
            this._isOutsideMapBounds()))) {
            this._stopLocate();
        } else {
            this._locateOnNextLocationFound = true;

            if (!this._active) {
                this._map.locate(this._locateOptions);
            }

            this._active = true;

            if (this.options.follow) {
                this._startFollowing();
            }

            this._clearError();

            if (this._event) {
                this._visualizeLocation();
            } else {
                this.setState('requesting');
            }
        }
    },

    _onLocationFound: function(e) {
        // no need to do anything if the location has not changed
        if (this._event &&
            (this._event.latlng.lat === e.latlng.lat &&
             this._event.latlng.lng === e.latlng.lng &&
             this._event.accuracy === e.accuracy)) {
            return;
        }

        if (!this._active) {
            return;
        }

        this._event = e;

        if (this.options.follow && this._following) {
            this._locateOnNextLocationFound = true;
        }

        this._visualizeLocation();
    },

    _startFollowing: function() {
        this._following = true;
        if (this.options.stopFollowingOnDrag) {
            this._map.on('dragstart', this._stopFollowing, this);
        }
    },

    _stopFollowing: function() {
        this._following = false;
        if (this.options.stopFollowingOnDrag) {
            this._map.off('dragstart', this._stopFollowing, this);
        }
        this._visualizeLocation();
    },

    _isOutsideMapBounds: function() {
        if (this._event === undefined) {
            return false;
        }
        return this._map.options.maxBounds &&
            !this._map.options.maxBounds.contains(this._event.latlng);
    },

    _visualizeLocation: function() {
        if (this._event.accuracy === undefined) {
            this._event.accuracy = 0;
        }

        var radius = this._event.accuracy;

        if (this._locateOnNextLocationFound) {
            if (this._isOutsideMapBounds()) {
                this.options.onLocationOutsideMapBounds(this);
            } else if (this._locateOptions.setView) {
                var project = this._map.projectDetector.getProject();
                var zoom = project ? project.maxZoom : DG.config.projectLeaveMaxZoom;
                zoom = Math.min(this._locateOptions.maxZoom, zoom);
                this._map.setView(this._event.latlng, zoom);
            }
            this._locateOnNextLocationFound = false;
        }

        // circle with the radius of the location's accuracy
        var style = {
            clickable: false,
            color: '#FFF',
            fillColor: '#FFF',
            fillOpacity: 0.4,
            weight: 0,
            opacity: 0.3
        };
        if (this.options.drawCircle) {
            if (!this._circle) {
                this._circle = DG.circle(this._event.latlng, radius, style)
                    .addTo(this._layer);
            } else {
                this._circle.setLatLng(this._event.latlng).setRadius(radius);
            }
        }

        var markerClass = 'dg-location__pin';

        markerClass += this._following ? (' ' + markerClass + 'state_following') : '';
        // small inner marker
        var m = {
            icon: DG.divIcon({
                className: markerClass,
                iconSize: [20, 20]
            })
        };

        if (!this._marker) {
            this._marker = DG.marker(this._event.latlng, m)
                .bindLabel(this.t('you_are_here'))
                .addTo(this._layer);
        } else {
            this._marker.setLatLng(this._event.latlng);
        }

        DG.DomEvent.on(this._marker, 'click', function() {
            this._map.fireEvent('dgLocateClick');
        }, this);

        if (!this._container) {
            return;
        }

        this.setState('active');
    },

    _resetVariables: function() {
        this._active = false;
        this._following = false;
    },


    _stopLocate: function() {
        this._map.stopLocate();
        this._map.off('dragstart', this._stopFollowing);

        this.setState();
        this._resetVariables();

        this._layer.clearLayers();
        this._marker = undefined;
        this._circle = undefined;
        this._event = undefined;
    },

    _onLocationError: function(err) {
        // ignore time out error if the location is watched
        if (err.code === 3 && this._locateOptions.watch) {
            return;
        }

        this._stopLocate();
        this._error = DG.DomUtil.create('div', 'dg-label dg-label_name_location-error', this._container);
        this._errorText = DG.DomUtil.create('div', 'dg-label__content', this._error);
        this._errorText.innerHTML = this.t('cant_find');

        var self = this;
        setTimeout(function() {
            self._clearError();
        }, 3000);

        //show location error
        this.options.onLocationError(err);
    },

    _clearError: function() {
        if (this._error) {
            this._container.removeChild(this._error);
            this._error = undefined;
            this._errorText = undefined;
        }
    },

    _renderTranslation: function() {
        if (this._link) {
            this._link.title = this.t('button_title');
        }
        if (this._marker) {
            this._marker.bindLabel(this.t('you_are_here'));
        }
    }
});

DG.control.location = function(options) {
    return new DG.Control.Location(options);
};

DG.Map.addInitHook(function() {
    if (this.options.locationControl) {
        this.locationControl = DG.control.location(this.options.locationControl);
        this.addControl(this.locationControl);
    }
});


================================================
FILE: src/DGLocation/test/DGLocationSpec.js
================================================
describe('DG.Location', function () {
    var mapContainer, position, map, control, classControl, classControlRequest,
        classControlActive, container, classPin;
    var left = 'leaflet-left', right = 'leaflet-right', top = 'leaflet-top', bottom = 'leaflet-bottom';

    before(function () {
        geolocate.use();

        mapContainer = document.createElement('div');
        document.body.appendChild(mapContainer);

        position = {lat: 54.910206086231, lng: 82.88806836200};
        map = new DG.Map(mapContainer, {
            center: [55.017493, 82.819576],
            zoom: 15,
            locationControl: true,
            key: window.__karma__.config.secretKey,
        });
        control = DG.control.location();

        classControl = 'dg-control-round__icon_name_locate';
        classControlRequest = 'dg-control-round__icon_state_requesting';
        classControlActive = 'dg-control-round__icon_state_active';
        container = document.body.getElementsByClassName(classControl);
        classPin = 'dg-location__pin';
    });

    after(function () {
        geolocate.restore();
        map.remove();
        mapContainer.parentElement.removeChild(mapContainer);
    });

    function initTests() {
        var locationControl;
        describe('check init', function () {
            it('should be html container on map', function () {
                expect(container.length).to.be(1);

                locationControl = container[0];
            });
        });

        describe('check clicks', function () {
            describe('click to enable', function () {
                before(function () {
                    happen.click(locationControl);
                });

                it('should change to request class', function () {
                    expect(locationControl.className).to.contain(classControlRequest);
                });

                it('should change to active class', function () {
                    geolocate.send(position);
                    expect(locationControl.className).to.contain(classControlActive);
                });

                it('should change center map near coord', function () {
                    expect(map.getCenter()).to.nearLatLng(DG.latLng(position));
                });

                it('should be location pin on map', function () {
                    expect(document.body.getElementsByClassName(classPin).length).to.be(1);
                });
            });

            describe('click to disable', function () {
                before(function () {
                    happen.click(locationControl);
                });

                it('should remove active class', function () {
                    expect(locationControl.className).not.contain(classControlActive);
                });

                it('shouldn\'t be location pin on map', function () {
                    expect(document.body.getElementsByClassName(classPin).length).to.be(0);
                });

                it('should center map near coord', function () {
                    expect(map.getCenter()).to.nearLatLng(DG.latLng(position));
                });
            });
        });

        describe('change position', function () {
            before(function () {
                geolocate.change(position);
            });

            it('should center map near coord', function () {
                expect(map.getCenter()).to.nearLatLng(DG.latLng(position));
            });
        });
    }

    describe('check auto init from map options', function () {
        initTests();
    });

    describe('check custom init', function () {
        before(function () {
            if (map.locationControl) {
                map.locationControl.remove();
            }

            map.addControl(control);
            container = document.body.getElementsByClassName(classControl);
        });

        initTests();

        after(function () {
            map.removeControl(control);
        });
    });

    describe('#addTo', function () {
        before(function () {
            if (map.locationControl) {
                map.locationControl.remove();
            }
            control.addTo(map);
        });

        initTests();

        after(function () {
            control.remove();
        });
    });

    describe('#remove', function () {
        before(function () {
            if (map.locationControl) {
                map.locationControl.remove();
                control.addTo(map);
            }
            control.remove(map);
        });

        it('control not present',function () {
            expect(container.length).to.be(0);
        });
    });

    describe('position init property', function () {
        var tmpControl, content;

        before(function () {
           if(map.locationControl){
               map.locationControl.remove();
           }
           control.remove(map);
        });

        it('default', function () {
            tmpControl = DG.control.location();
            content = document.querySelector(classControl) == document.querySelector([top, left].join('.'));
            expect(tmpControl.getPosition()).to.be('topleft');
            expect(content).to.be.ok();

        });

        it('topleft', function () {
            tmpControl = DG.control.location({position: 'topleft'});
            content = document.querySelector(classControl) == document.querySelector([top, left].join('.'));
            expect(tmpControl.getPosition()).to.be('topleft');
            expect(content).to.be.ok();
        });

        it('topright', function () {
            tmpControl = DG.control.location({position: 'topright'});
            content = document.querySelector(classControl) == document.querySelector([top, right].join('.'));
            expect(tmpControl.getPosition()).to.be('topright');
            expect(content).to.be.ok();
        });

        it('bottomleft', function () {
            tmpControl = DG.control.location({position: 'bottomleft'});
            content = document.querySelector(classControl) == document.querySelector([bottom, left].join('.'));
            expect(tmpControl.getPosition()).to.be('bottomleft');
            expect(content).to.be.ok();
        });

        it('topleft', function () {
            tmpControl = DG.control.location({position: 'bottomright'});
            content = document.querySelector(classControl) == document.querySelector([bottom, right].join('.'));
            expect(tmpControl.getPosition()).to.be('bottomright');
            expect(content).to.be.ok()
        });
    });

});


================================================
FILE: src/DGMeta/src/DGMeta.Layer.js
================================================
DG.Meta = {};

DG.Meta.Layer = DG.Layer.extend({

    options: {
        tileSize: 256,

        minZoom: 0,
        maxZoom: 19,
        zoomOffset: 0,
        eventBubbling: 'transparent'
        // maxNativeZoom: <Number>,
        // detectRetina: <Number>,
        // zoomReverse: <Number>
        // attribution: <String>,
        // zIndex: <Number>,
        // bounds: <LatLngBounds>
    },

    initialize: function(source, options) { // (String, Object)
        DG.TileLayer.prototype.initialize.call(this, null, options);
        delete this._url;

        this._currentTileKey = '';
        this._currentTileData = [];
        this._lastEntity = undefined;
        this._dispatchMouseEvents = true;

        this._origin = DG.Meta.origin(source, {
            dataFilter: this.options.dataFilter
        });
    },

    getOrigin: function() { // () -> Object
        return this._origin;
    },

    onAdd: function(map) {
        this._resetView();

        map.metaLayers.push(this);

        map.on('rulerstart', this._disableDispatchMouseEvents, this);
        map.on('rulerend', this._enableDispatchMouseEvents, this);

        var self = this;

        if (DG.Browser.touchEnabled && this.options.isPoi) {
            map.eachLayer(function(layer) {
                if (layer instanceof L.TileLayer) {
                    // On every tile will be load meta tile.
                    layer.on('tileloadstart', self._onTileLoadStart, self);
                    // Load metatiles for already loaded tiles.
                    for (var tile in layer._tiles) {
                        self._onTileLoadStart({
                            coords: layer._tiles[tile].coords
                        });
                    }
                }
            });
        }
    },

    onRemove: function(map) {
        var self = this;

        if (DG.Browser.touchEnabled && this.options.isPoi) {
            map.eachLayer(function(layer) {
                if (layer instanceof L.TileLayer) {
                    // On every tile will be load meta tile.
                    layer.off('tileloadstart', self._onTileLoadStart);
                }
            });
        }

        this._tileZoom = null;

        var index = map.metaLayers.indexOf(this);
        if (index !== -1) {
            map.metaLayers.splice(index, 1);
        }

        map.off('rulerstart', this._disableDispatchMouseEvents, this);
        map.off('rulerend', this._enableDispatchMouseEvents, this);
    },

    getEvents: function() {
        return {
            viewprereset: this._invalidateAll,
            viewreset: this._resetView,
            zoom: this._resetView,
            moveend: this._onMoveEnd
        };
    },

    setUrl: function(url) {
        this._currentTileKey = '';
        this._currentTileData = [];
        this._lastEntity = undefined;
        this._dispatchMouseEvents = true;
        this._origin.setURL(url, true);
    },

    getHoveredObject: function(event) {
        var tileSize = this.getTileSize(),
            layerPoint = this._map.mouseEventToLayerPoint(event.originalEvent),
            tileOriginPoint = this._map.getPixelOrigin().add(layerPoint),
            tileCoord = tileOriginPoint.unscaleBy(tileSize).floor(),
            mouseTileOffset = DG.point(tileOriginPoint.x % tileSize.x, tileOriginPoint.y % tileSize.y),
            tileKey,
            zoom = this._map.getZoom(),
            self = this;

        if (zoom > (this.options.maxZoom + this.options.zoomOffset) ||
            zoom < (this.options.minZoom - this.options.zoomOffset) ||
            !this._isValidTile(tileCoord)) {
            return;
        }

        this._wrapCoords(tileCoord);

        tileCoord.z = this._getZoomForUrl();
        tileCoord.key = tileSize.x + 'x' + tileSize.y;
        tileCoord.apiKey = self._map.options.key;
        tileKey = this._origin.getTileKey(tileCoord);

        if (tileKey === this._currentTileKey) {
            self._lastEntity = self._getHoveredObject(mouseTileOffset);
        } else {
            this._origin.getTileData(tileCoord, function(tileData) {
                self._currentTileKey = tileKey;
                self._currentTileData = tileData;
                self._lastEntity = self._getHoveredObject(mouseTileOffset);
            });
        }

        return this._lastEntity;
    },

    _removeAllTiles: DG.GridLayer.prototype._removeAllTiles,
    _getZoomForUrl: DG.TileLayer.prototype._getZoomForUrl,
    getTileSize: DG.TileLayer.prototype.getTileSize,
    _isValidTile: DG.GridLayer.prototype._isValidTile,
    _wrapCoords: DG.GridLayer.prototype._wrapCoords,
    _resetView: DG.GridLayer.prototype._resetView,
    _resetGrid: DG.GridLayer.prototype._resetGrid,
    _invalidateAll: DG.GridLayer.prototype._invalidateAll,
    _pxBoundsToTileRange: DG.GridLayer.prototype._pxBoundsToTileRange,

    // Fix for https://github.com/Leaflet/Leaflet/compare/0726f12bbf33fcb18fe8bb541d5e3212bb1f5ab2...c263f2d8b1bd962b60474376cc4816a688052513#diff-f1e6be67599c594731fff6191c710420L579
    _onMoveEnd: function() {
        if (!this._map || this._map._animatingZoom) { return; }

        this._resetView();
    },

    _onTileLoadStart: function(e) {
        var tileSize = this.getTileSize();
        e.coords.key = tileSize.x + 'x' + tileSize.y;
        this._origin.getTileData(e.coords);
    },

    _enableDispatchMouseEvents: function() {
        this._dispatchMouseEvents = true;
    },

    _disableDispatchMouseEvents: function() {
        this._dispatchMouseEvents = false;
    },

    mapEvents: {
        mousemove: function(event) {
            this._fireMetalayerEvent('mousemove', event);
        },

        mouseover: function(event) {
            this._fireMetalayerEvent('mouseover', event);
        },

        mouseout: function(event) {
            this._fireMetalayerEvent('mouseout', event);
            this._currentTileKey = '';
        },

        click: function(event) {
            var tileSize = this.getTileSize(),
                layerPoint = this._map.mouseEventToLayerPoint(event.originalEvent),
                tileOriginPoint = this._map.getPixelOrigin().add(layerPoint),
                tileCoord = tileOriginPoint.unscaleBy(tileSize).floor(),
                mouseTileOffset = DG.point(tileOriginPoint.x % tileSize.x, tileOriginPoint.y % tileSize.y);
            tileCoord.z = this._getZoomForUrl();
            tileCoord.key = tileSize.x + 'x' + tileSize.y;
            var tileKey = this._origin.getTileKey(tileCoord);
            var self = this;

            // In this function the tile meta data are processed by metalayer.
            var onTileData = function(currentTileData) {
                self._currentTileData = currentTileData;
                self._currentTileKey = tileKey;
                self._lastEntity = self._getHoveredObject(mouseTileOffset);
                self._mouseDown = false;

                if (self._lastEntity) {
                    event.entity = self._lastEntity;
                    self._fireMetalayerEvent('click', event);
                }
            }

            // For more information about the code below see:
            // https://github.com/2gis/mapsapi/pull/501
            this._origin.getTileData(tileCoord, function(tileData) {
                if (tileData) {
                    onTileData(tileData);
                } else if (self._origin._requests[tileKey]) {
                    DG.DomEvent.stop(event);
                    self._origin._requests[tileKey].then(function() {
                        delete event.originalEvent._stopped;
                        onTileData(self._origin._tileStorage[tileKey]);
                        if (!event.originalEvent._stopped) {
                            var targets = event.eventTargets;
                            for (var i = event.eventTargetsMapIndex; i < targets.length; i++) {
                                targets[i].fire('click', event, true);
                                if (
                                    event.originalEvent._stopped ||
                                    (targets[i].options.nonBubblingEvents &&
                                    L.Util.indexOf(targets[i].options.nonBubblingEvents, 'click') !== -1)
                                ) {
                                    return;
                                }
                            }
                        }
                    });
                }
            });
        },

        dblclick: function(event) {
            this._fireMetalayerEvent('dblclick', event);
        },

        mousedown: function(event) {
            this._mouseDown = true;
            this._fireMetalayerEvent('mousedown', event);
        },

        contextmenu: function(event) {
            this._fireMetalayerEvent('contextmenu', event);
        }
    },

    _fireMetalayerEvent: function(type, mouseEvent) {
        if (!mouseEvent.entity || !this._dispatchMouseEvents) {
            return;
        }
        this.fire(type, {
            meta: mouseEvent.entity,
            latlng: this._map.mouseEventToLatLng(mouseEvent.originalEvent)
        });
        var isDragging = type === 'mousedown' || (this._mouseDown && type === 'mousemove');
        if (this.options.eventBubbling === 'layer' && !isDragging) {
            DG.DomEvent.stop(mouseEvent);
        }
    },

    _getHoveredObject: function(mouseTileOffset) {
        if (!this._currentTileData) {
            return;
        }

        for (var i = 0; i < this._currentTileData.length; i++) {
            if (DG.PolyUtil.inside(mouseTileOffset, this._currentTileData[i].geometry, this._pointReduceHelper)) {
                return this._currentTileData[i];
            }
        }
    },

    _pointReduceHelper: function(point) {
        return [point.x, point.y];
    },

    _setView: function(center, zoom, noPrune, noUpdate) {
        var tileZoom = Math.round(zoom),
            tileZoomChanged = this._tileZoom !== tileZoom;

        if (!noUpdate && tileZoomChanged) {
            this._tileZoom = tileZoom;
            this._resetGrid();
        }
    }
});

DG.Meta.layer = function(source, options) {
    return new DG.Meta.Layer(source, options);
};


================================================
FILE: src/DGMeta/src/DGMeta.Origin.js
================================================
DG.Meta.Origin = DG.Class.extend({

    options: {
        subdomains: '0123',
        dataFilter: null
    },

    _url: false,

    initialize: function(url, options) { // (String, Object)
        this._url = url;
        this._requests = {};

        this._tileStorage = {};

        options = DG.setOptions(this, options);

        if (typeof options.subdomains === 'string') {
            options.subdomains = options.subdomains.split('');
        }
    },

    getTileData: function(coord, clb) { // (Object) -> Object
        var tileKey = this.getTileKey(coord),
            self = this,
            callback = typeof clb === 'function' ? clb : function() {};

        // if the tile meta data request in progress, this function returns false, it is therefore synchronous.
        if (typeof this._tileStorage[tileKey] === 'undefined' && typeof this._requests[tileKey] === 'undefined') {
            this._tileStorage[tileKey] = false;
            var currentRequest = this._requests[tileKey] = this._requestData(coord).then(function(data) {
                if (self._requests[tileKey] !== currentRequest) {
                    callback(false);
                    return;
                }
                self.setTileData(tileKey, self.options.dataFilter ? self.options.dataFilter(data, coord) : data);
                delete self._requests[tileKey];
                callback(self._tileStorage[tileKey]);
            });
        } else {
            callback(this._tileStorage[tileKey]);
        }
    },

    setTileData: function(key, data) { // (Object/String, Object) -> Object
        if (typeof key !== 'string') {
            key = this.getTileKey(key);
        }

        data.forEach(function(entity) {
            if (entity.geometry.constructor !== Object) {
                entity.geometry = DG.Wkt.toGeoJSON(entity.geometry);
            }
            if (!this._tileStorage[key]) {
                this._tileStorage[key] = [];
            }
            this._tileStorage[key].push(entity);
        }, this);

        return this;
    },

    flush: function() { // () -> Object
        this._tileStorage = {};
        Object.keys(this._requests).forEach(function(tileKey) {
            if (this[tileKey].abort) {
                this[tileKey].abort();
            }
        }, this._requests);
        this._requests = {};

        return this;
    },

    setURL: function(url, flush) { // (String, Boolean) -> Object
        this._url = url;
        if (flush) {
            this.flush();
        }

        return this;
    },

    getTileKey: function(coord) { // (Object)-> String
        return [coord.x, coord.y, coord.z, coord.key].join(':');
    },

    _requestData: function(key) { // (String)
        if (this._url) {
            return this._performRequest(key);
        } else {
            return Promise.resolve([]);
        }
    },

    _performRequest: function(coords) { // (Object) -> Promise
        return DG.ajax(this._prepareURL(coords), {
            type: 'get',
            dataType: 'json'
        });
    },

    _prepareURL: function(coords) { // (Object) -> String
        return DG.Util.template(this._url, {
            x: coords.x,
            y: coords.y,
            z: coords.z,
            s: this._getSubdomain(coords),
            key: coords.apiKey
        });
    },

    _getSubdomain: DG.TileLayer.prototype._getSubdomain

});

DG.Meta.origin = function(source, options) {
    return new DG.Meta.Origin(source, options);
};


================================================
FILE: src/DGMeta/test/DGMetaSpec.js
================================================
describe.skip('DGMeta', function () {
    var map, meta, ajaxSpy, ajaxStub, demoData, origin, poiCord, spy, div;

    beforeEach(function () {
        div = document.createElement('div');

        document.body.appendChild(div);

        map = new DG.Map(div, {
            center : new DG.LatLng(54.980206086231, 82.898068362003),
            zoom: 17,
            key: window.__karma__.config.secretKey,
        });

        demoData = [{
            geometry: {
                type: 'Polygon',
                coordinates: [
                    DG.point(20, 85),
                    DG.point(40, 85),
                    DG.point(40, 105),
                    DG.point(20, 105),
                    DG.point(20, 85)
                ]
            },
            hint: 'Суши Терра, сеть ресторанов японской кухни',
            id: '141806935215016',
            linked: {
                id: '141265769904776',
                name: 'Суши Терра, сеть ресторанов японской кухни',
                type: 'filial'
            }
        }];

        poiCord = DG.latLng(51.73106181684307, 36.19431853294373); // администрация курской области

        meta = DG.Meta.layer(null);
        origin = meta.getOrigin();

        ajaxSpy = sinon.spy();
        ajaxStub = sinon.stub(DG, 'ajax', function () {
            ajaxSpy();
            return {then: function () {} };
        });

    });

    afterEach(function () {
        document.body.removeChild(div);
        map && map.remove();
        map = meta = origin = demoData = ajaxSpy = null;
        ajaxStub.restore();
    });

    describe('#DG.Meta.Layer', function () {
        it('should create and return origin instance', function () {
            expect(origin).to.be.an('object');
        });

        it('should click on map', function () {
            origin.setTileData('78713:43453:17:256x256', demoData);
            spy = sinon.spy();
            meta.addTo(map);

            map.on('click', spy);

            happen.click(map.getPane('tilePane'), {latlng: poiCord});

            expect(spy.called).to.be.ok();
        });
    });

    describe('#DG.Meta.Origin', function () {
        it('getTileData should NOT call ajax and return false', function () {
            origin.getTileData('124:12:42:256x256', function (tileData) {
                expect(tileData).to.not.be.ok();
                // ajax should not be called since empty url provided
                expect(ajaxSpy.callCount).to.be.eql(0);
            });
        });

        it('flush should clear cache', function () {
            var chain;

            origin.setTileData({x: 124, y: 12, z: 42, key: '256x256'}, demoData);
            chain = origin.flush();
            origin.getTileData({x: 124, y: 12, z: 42, key: '256x256'}, function (tileData) {
                expect(tileData).to.not.be.ok();
                // check for returning this
                expect(chain.flush).to.be.a('function');
            });
        });

        it('setURL flush option call flush method', function () {
            var flushSpy = sinon.spy();
                flushStub = sinon.stub(DG.Meta.Origin.prototype, 'flush', function () {
                    flushSpy();
                });

            origin.setURL('http://demo/data', true);

            expect(flushSpy.callCount).to.be.eql(1);

            flushStub.restore();
        });

        it('getTileData should cache tileData', function () {
            origin.setURL('http://demo/data');
            origin.getTileData({x: 124, y: 12, z: 42, key: '256x256'}, function (tileData) {
                expect(tileData).to.not.be.ok();
                expect(ajaxSpy.callCount).to.be.eql(1);
            });
        });

        it('setTileData by object key should write and cache tileData', function () {
            var chain;

            chain = origin.setTileData({x: 124, y: 12, z: 42, key: '256x256'}, demoData);

            origin.getTileData({x: 124, y: 12, z: 42, key: '256x256'}, function (tileData) {
                expect(tileData).to.be.a('object');
                expect(ajaxSpy.callCount).to.be.eql(0);
                // check for returning this
                expect(chain.setTileData).to.be.a('function');
            });
        });

        it('setTileData by string key should write and cache tileData', function () {
            var chain;

            chain = origin.setTileData('124:12:42:256x256', demoData);

            origin.getTileData({x: 124, y: 12, z: 42, key: '256x256'}, function (tileData) {
                expect(tileData).to.be.a('object');
                expect(ajaxSpy.callCount).to.be.eql(0);
                // check for returning this
                expect(chain.setTileData).to.be.a('function');
            });
        });

        it('getTileKey should string tileKey representation', function () {
            var tileKey;

            tileKey = origin.getTileKey({x: 124, y: 12, z: 42, key: '256x256'});

            expect(tileKey).to.be.eql('124:12:42:256x256');
        });
    });
});


================================================
FILE: src/DGMeta/test/PolyUtilContainsSpec.js
================================================
/*global describe:false, it:false, expect:false */

describe('Polygon', function () {

    var polygonPointSet = [
        [54.97952237000778, 82.89766073226929],
        [54.98081530831201, 82.89707064628601],
        [54.980944599852364, 82.89730668067932],
        [54.98121549506299, 82.89891600608826],
        [54.98071372180964, 82.89812743663788],
        [54.98069832989291, 82.89967775344849],
        [54.97954084084813, 82.8976821899414]
    ],
    innerPoints = [
        [54.98067985958506, 82.89960801601408],
        [54.98059366470269, 82.89906620979309],
        [54.98043974480962, 82.89858877658844],
        [54.98023041280807, 82.89815425872803],
        [54.98044590161669, 82.89755344390868],
        [54.9806459973319, 82.8972852230072],
        [54.98087379739374, 82.89828300476074],
        [54.98009804053787, 82.89771437644957],
        [54.97958393944262, 82.89766609668732],
        [54.980141138534236, 82.8980898857116],
        [54.98067370281387, 82.89959192276001],
        [54.98089226761238, 82.89737641811371]
    ],
    outerPoints = [
        [54.98049823443851, 82.89948463439941],
        [54.981049264127705, 82.89756953716278],
        [54.98056903755945, 82.89710283279419],
        [54.980950756582004, 82.89888918399811],
        [54.980113432684746, 82.89712429046631],
        [54.98108004768617, 82.89791285991669],
        [54.979744019531346, 82.90242433547974],
        [54.980113432684746, 82.89015054702759],
        [54.98220670968463, 82.89379835128784],
        [54.981049264127705, 82.90077209472656]
    ];

    describe('#inside', function () {
        it('should return true if points are inside', function () {
            for (var i = 0; i < innerPoints.length; i++) {
                expect(DG.PolyUtil.inside(innerPoints[i], {
                    type: 'Polygon',
                    coordinates: [polygonPointSet]
                })).to.be.equal(true);
            }
        });

        it('should return false if points are outside', function () {
            for (var i = 0; i < outerPoints.length; i++) {
                expect(DG.PolyUtil.inside(outerPoints[i], {
                    type: 'Polygon',
                    coordinates: [polygonPointSet]
                })).to.be.equal(false);
            }
        });

    });

});


================================================
FILE: src/DGMuseum/skin/basic/less/dg-museum.less
================================================
.dg-museum {
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    z-index: 1500;
    padding: 4px 5px 8px;
    background: #333;
    color: #fff;
    opacity: .97;
    text-align: center;
}

.dg-museum-browser {
    position: relative;
    top: 4px;
    display: inline-block;
    width: 16px;
    height: 16px;
    margin: 0 4px;
    background: url('@{baseURL}/img/DGMuseum.jpg') left top no-repeat;
}
.dg-museum__chrome {
    background-position: 0 0;

    &:hover {
        background-position: 0 -16px;
        }
    }
.dg-museum__firefox {
    background-position: -16px 0;

    &:hover {
        background-position: -16px -16px;
        }
    }
.dg-museum__safari {
    background-position: -32px 0;

    &:hover {
        background-position: -32px -16px;
        }
    }
.dg-museum__opera {
    width: 15px;
    background-position: -48px 0;

    &:hover {
        background-position: -48px -16px;
        }
    }
.dg-museum__ie {
    width: 17px;
    background-position: -63px 0;

    &:hover {
        background-position: -63px -16px;
        }

    }
.dg-museum__close {
    display: inline-block;
    margin: 0 4px;
    width: 9px;
    height: 9px;
    background: url('@{baseURL}/img/DGMuseum_close.gif') top left no-repeat;
    cursor: pointer;

    &:hover {
        opacity: .6;
        }
    }


================================================
FILE: src/DGMuseum/src/DGMuseum.js
================================================
var ie9 = (function() {
    var div = document.createElement('div');
    var all = div.getElementsByTagName('i');
    div.innerHTML = '<!--[if IE 9]><i></i><![endif]-->';
    return Boolean(all[0]);
})();

var safari51 = DG.Browser.safari && navigator.userAgent.indexOf('Version/5.1') !== -1;

var wasPreviouslyDisabled = false;

// Old Safari throws error when localStorage.getItem is called in private mode
try {
    wasPreviouslyDisabled = localStorage.getItem('DGMuseum') === 'false';
} catch (err) {
    // do nothing
}

DG.Map.mergeOptions({
    museum: !wasPreviouslyDisabled && (DG.Browser.ielt9 || ie9 || DG.Browser.opera12 || safari51)
});

DG.Map.Museum = DG.Handler.extend({
    statics: {
        Dictionary: {
            ar: {
                wearesorry: 'لا نضمن لك تشغيل ثابت للتطبيق على متصفحك. حاول التحديث:'
            },
            cs: {
                wearesorry: 'Nezaručujeme stabilní fungování aplikace ve Vašem prohlížeči. Zkuste provést aktualizaci:'
            },
            en: {
                wearesorry: 'We do not guarantee stable operation of the application in your browser. Try updating:'
            },
            es: {
                wearesorry: 'No garantizamos un funcionamiento estable de la aplicación en su buscador. Intente actualizarlo:'
            },
            it: {
                wearesorry: 'Non garantiamo il funzionamento stabile dell\'applicazione nel tuo browser. Prova ad aggiornare:'
            },
            ru: {
                wearesorry: 'Мы не гарантируем стабильную работу приложения в вашем браузере. Попробуйте обновиться:'
            }
        }
    },

    includes: [DG.Locale],

    initialize: function(map) {
        this._map = map;

        this._element = document.createElement('div');
        this._element.className = 'dg-museum';
        this._element.innerHTML = '<span></span>' +
            '<a class="dg-museum-browser dg-museum__chrome" target="_blank" href="https://www.google.com/chrome/"></a>' +
            '<a class="dg-museum-browser dg-museum__firefox" target="_blank" href="https://www.mozilla.org/firefox/new/"></a>' +
            '<a class="dg-museum-browser dg-museum__safari" target="_blank" href="https://support.apple.com/downloads/safari"></a>' +
            '<a class="dg-museum-browser dg-museum__opera" target="_blank" href="https://www.opera.com/"></a>' +
            '<a class="dg-museum-browser dg-museum__ie" target="_blank" href="https://windows.microsoft.com/internet-explorer/download-ie"></a>';

        this._text = this._element.children[0];

        this._closeButton = document.createElement('span');
        this._closeButton.className = 'dg-museum__close';
        this._element.appendChild(this._closeButton);

        this._renderTranslation();
    },

    addHooks: function() {
        this._map.getContainer().appendChild(this._element);
        this._map.on('langchange', this._renderTranslation, this);
        DG.DomEvent.on(this._closeButton, 'click', this._onCloseButtonClick, this);
    },

    removeHooks: function() {
        this._map.getContainer().removeChild(this._element);
        this._map.off('langchange', this._renderTranslation, this);
        DG.DomEvent.off(this._closeButton, 'click', this._onCloseButtonClick, this);
    },

    _onCloseButtonClick: function(e) {
        DG.DomEvent.stop(e);

        // Old Safari throws error when localStorage.getItem is called in private mode
        try {
            localStorage.setItem('DGMuseum', 'false');
        } catch (err) {
            // do nothing
        }

        this.disable();
    },

    _renderTranslation: function() {
        var lang = this._map.getLang();
        this._text.innerHTML = this.t('wearesorry');
        this._element.setAttribute('dir', lang === 'ar' ? 'rtl': 'ltr');
    }
});

DG.Map.addInitHook('addHandler', 'museum', DG.Map.Museum);


================================================
FILE: src/DGPoi/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>

    <title>poi demo</title>
    <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>
    <style type="text/css">
        html,body { height: 100%; margin: 0; padding: 0; }
        #map { width: 100%; height: 100%; }
    </style>
</head>
<body>
    <div id="map"></div>
    <script type="text/javascript">
        DG.then(function () {
            var map = new DG.Map('map', {
                center: new DG.LatLng(51.7302800, 36.1938900),
                zoom: 17,
                geoclicker: true,
                key: DG.config.key || 'Your API access key'
            });

            var marker = DG.marker(map.getCenter()).addTo(map);

            map.poi.getMetaLayer().on('click', function(e) {
                console.log('poi click!', e)
            })

            map.poi.getMetaLayer().on('mouseover', function(e) {
                console.log('poi hover!', e)
            })
        });
    </script>
</body>
</html>


================================================
FILE: src/DGPoi/src/DGPoi.js
================================================
DG.Map.mergeOptions({
    poi: true
});

DG.Poi = DG.Handler.extend({

    options: {
        disableLabel: false
    },

    initialize: function(map, options) { // (Object)
        this._map = map;
        DG.Util.setOptions(this, options);

        var url = DG.config.protocol + (DG.Browser.retina ? DG.config.retinaPoiMetaServer : DG.config.poiMetaServer);

        this._metaLayer = DG.Meta.layer(url, {
            minZoom: DG.config.poiLayerMinZoom,
            maxNativeZoom: 19,
            detectRetina: DG.config.detectRetina,
            eventBubbling: 'layer',
            dataFilter: DG.bind(this._processData, this),
            isPoi: true
        });

        this._currentTilesLang = ''; // 'ar' | ''
    },

    addHooks: function() {
        this._map.addLayer(this._metaLayer);
        if (!this.options.disableLabel) {
            this._labelHelper = DG.label();
        }
        this._metaLayer.on(this._layerEventsListeners, this);
        this._map.on('langchange', this._updateUrl, this);
        this._map.on('projectchange', this._updateUrl, this);
        this._map.on('projectleave', this._updateUrl, this);
    },

    removeHooks: function() {
        this._map.removeLayer(this._metaLayer);
        if (!this.options.disableLabel) {
            this._map.removeLayer(this._labelHelper);
            this._labelHelper = null;
        }
        this._metaLayer.off(this._layerEventsListeners, this);
        this._map.off('langchange', this._updateUrl, this);
        this._map.off('projectchange', this._updateUrl, this);
        this._map.off('projectleave', this._updateUrl, this);
    },

    getMetaLayer: function() {
        return this._metaLayer;
    },

    _updateUrl: function() {
        var url = DG.config.protocol + (DG.Browser.retina ? DG.config.retinaPoiMetaServer : DG.config.poiMetaServer);
        var arabicUrl = DG.config.protocol +
            (DG.Browser.retina ? DG.config.arabicRetinaPoiMetaServer : DG.config.arabicPoiMetaServer);
        var lang = this._map.getLang();
        var project = this._map.projectDetector && this._map.projectDetector.getProject();

        // Change POI for Arabic language in Dubai project
        if (this._currentTilesLang === '' && lang === 'ar' && project && project.country_code === 'ae') {
            this._currentTilesLang = 'ar';
            this._metaLayer.setUrl(arabicUrl);

        } else if (this._currentTilesLang === 'ar' && (lang !== 'ar' || (!project || project.country_code !== 'ae'))) {
            this._currentTilesLang = '';
            this._metaLayer.setUrl(url);
        }
    },

    _processData: function(data, coord) {
        var tileOriginPoint = coord.scaleBy(this._metaLayer.getTileSize());
        var polygonLngLatToPoints = DG.bind(this._polygonLngLatToPoints, this, tileOriginPoint, coord.z);

        if (data.responseText === '') {
            return [];
        }

        return data.result.poi
            .map(function(item) {
                var hovers = item.hovers !== undefined
                    ? item.hovers
                    : [item.hover];

                return {
                    id: item.id,
                    hint: item.links[0].name,
                    linked: item.links[0],
                    geometry: hovers.map(DG.Wkt.toGeoJSON),
                };
            })
            .map(function(item) {
                var coordinates = item.geometry.reduce(function(result, item) {
                    if (item.type === 'Polygon') {
                        result.push(polygonLngLatToPoints(item.coordinates));
                    } else if (item.type === 'MultiPolygon') {
                        result = result.concat(item.coordinates.map(polygonLngLatToPoints));
                    }

                    return result;
                }, []);

                item.geometry = {
                    type: 'MultiPolygon',
                    coordinates: coordinates,
                };

                return item;
            });
    },

    _polygonLngLatToPoints: function(originPoint, zoom, polygon) {
        var map = this._map;

        return polygon.map(function(contour) {
            return contour.map(function(lngLat) {
                return map
                    .project([lngLat[1], lngLat[0]], zoom).round()
                    .subtract(originPoint);
            });
        });
    },

    _layerEventsListeners : {
        mouseover: function(e) { // (Object)
            this._setCursor('pointer');
            if (e.meta.hint && e.meta.hint.length && !this.options.disableLabel) {
                this._labelHelper
                    .setPosition(e.latlng)
                    .setContent(e.meta.hint)
                    .setZIndexOffset(300);
                this._map.addLayer(this._labelHelper);
            }
            this._map.fire('poihover', {
                latlng: e.latlng,
                meta: e.meta
            });
        },

        mouseout: function(e) {
            this._setCursor('');
            if (!this.options.disableLabel) {
                this._map.removeLayer(this._labelHelper);
            }
            this._map.fire('poileave', {
                latlng: e.latlng,
                meta: e.meta
            });
        },

        mousemove: function(e) { // (Object)
            if (!this.options.disableLabel) {
                this._labelHelper.setPosition(e.latlng);
            }
        }
    },

    _setCursor: function(cursor) { // (String)
        this._map.getContainer().style.cursor = cursor;
    }

});

DG.Map.addInitHook('addHandler', 'poi', DG.Poi);


================================================
FILE: src/DGPoi/test/DGPoiSpec.js
================================================
describe('DG.Poi', function() {
    var map, mapContainer, ajaxSpy, ajaxStub, tileData, tileKey;

    before(function() {
        mapContainer = document.createElement('div');
        document.body.appendChild(mapContainer);

        map = new DG.Map(mapContainer, {
            center: [55.017493, 82.819576],
            zoom: 15,
            key: window.__karma__.config.secretKey,
        });

        tileKey = '23929:10367:15:256';
        tileData = JSON.parse('[{"id":"141806935212060","hint":"Сан Сити, многофункциональный комплекс","linked":{"id":"141265770417218","type":"branch","name":"Сан Сити, многофункциональный комплекс"},"geometry":{"type":"Polygon","coordinates":[[{"x":142,"y":132},{"x":162,"y":132},{"x":162,"y":152},{"x":142,"y":152},{"x":142,"y":132}]]}}]');
        tileData[0].geometry.coordinates[0].forEach(function(el, i) {
            tileData[0].geometry.coordinates[0][i] = DG.point(el.x, el.y);
        });
    });

    after(function() {
        map.remove();
        mapContainer.parentElement.removeChild(mapContainer);
        map = mapContainer = ajaxSpy = ajaxStub = tileData = tileKey = null;
    });

    describe('check init', function() {
        it('should object map has .poi', function() {
            expect(map.poi).to.be.a('object');
        });

        it('should map has poi meta layer', function() {
            expect(map.hasLayer(map.poi.getMetaLayer())).to.be.ok();
        });
    });

    describe('#removeHooks', function() {
        before(function() {
            map.poi.removeHooks();
        });

        it('should map hasn\'t meta layer', function() {
            expect(map.hasLayer(map.poi.getMetaLayer())).not.be.ok();
        });
    });

    describe('#addHooks', function() {
        before(function() {
            map.poi.addHooks();
        });

        it('should map has meta layer', function() {
            expect(map.hasLayer(map.poi.getMetaLayer())).to.be.ok();
        });
    });

    describe('mouse events', function() {
        var labelContent, metaLayer;

        before(function() {
            metaLayer = map.poi.getMetaLayer();
            metaLayer.getOrigin().setTileData(tileKey, tileData);
        });

        after(function() {
            labelContent = metaLayer = null;
        });

        describe('#mouseover', function() {
            before(function() {
                metaLayer.fire('mouseover', {
                    meta: tileData[0],
                    latlng: DG.latLng(54.98042127438281, 82.89879798889162)
                });
            });

            it('should view label on map', function() {
                labelContent = document.body.getElementsByClassName('dg-label__content');
                expect(labelContent.length).to.be(1);
            });

            it('should equel label text', function() {
                expect(labelContent[0].innerHTML).to.be(tileData[0].hint);
            });
        });

        describe('#mouseout', function() {
            before(function() {
                metaLayer.fire('mouseout', {
                    meta: tileData[0],
                    latlng: DG.latLng(54.98042127438281, 82.89879798889162)
                });
            });

            it('shouldn\'t view label on map', function() {
                labelContent = document.body.getElementsByClassName('dg-label__content');
                expect(labelContent.length).to.be(0);
            });

        });
    });
});


================================================
FILE: src/DGPopup/skin/basic/less/dg-popup.less
================================================
.dg-popup {
}

.dg-popup__container {
    margin: 0;
}

.leaflet-popup-scrolled .dg-popup__container { /* @TODO: .leaflet-popup-scrolled → dg-popup_scrolled_true */
    padding: 8px 14px 8px 0;
}

.dg-popup__header {
    position: relative;
    padding-bottom: 12px; // не margin, чтобы правильно работал offsetHeight

    .leaflet-popup-scrolled &:after {
        position: relative;
        top: 12px;
        display: block;
        width: 100%;
        height: 1px;
        content: '';
    }
}

.dg-popup__footer {
    position: relative;
    bottom: 0;
    overflow: hidden;

    .leaflet-popup-scrolled &:before {
        display: block;
        width: 100%;
        height: 1px;
        content: '';
    }
}

.dg-popup__footer-buttons {
}

.dg-popup_hidden_true {
    display: none;
}


================================================
FILE: src/DGPopup/skin/basic/less/leaflet.ie.less
================================================
.leaflet-map-pane .leaflet-popup-tip-container {
    bottom: -47px;
    transform: translateY(0);
}


================================================
FILE: src/DGPopup/skin/basic/less/leaflet.less
================================================
.leaflet-popup {
    margin-bottom: 0;
}

.leaflet-popup-tip-container {
    height: 0;
}

.leaflet-popup-tip {
    display: none;
}

.leaflet-popup-content-wrapper {
    overflow: hidden;
    padding: 0;
    min-width: 60px;
    min-height: 50px;
    border: 0;
    border-radius: 3px;
    background: none;
    box-shadow: none;
    color: #e6e6e6;
    font-size: 14px;
    transition: opacity ease-out .2s, max-height ease-out .2s, height ease-out .2s;
    transform-origin: 50% 100%;

    // Чтобы текст не заезжал под кнопку закрытия. Для не инлайновых боксов
    // можно получить нужное поведение применяя к ним overflow:hidden или display:(inline-block|table) .
    &:before {
        float: right;
        width: 30px;
        // popupPadding + 1 , первая строчка текста уже среагирует на кнопку,
        // но минимум проблем с не инлайновыми боксами
        height: 17px;
        content: '';
    }
}

.leaflet-popup-content {
    position: relative;
    margin: 16px;
    width: auto;
    line-height: 1.4;
}

.leaflet-popup a {
    outline: none;
}

.leaflet-popup-content p {
    margin: 0;
}

.leaflet-popup-scrolled {
    overflow: visible;
    border: 0;
}

.leaflet-popup-inner {
    position: relative;
    z-index: 0;
}

.leaflet-popup_show_true {
    transition: transform ease-in-out .2s, opacity ease-in-out .2s, height ease-out .2s;
    transform: scale(1);
}

.leaflet-popup_show_false {
    opacity: 0 !important;
    transition: all ease-in-out .1s;
    transform: scale(.2);
}

/* Коллаут показался, но контент ещё не загрузился */
.leaflet-popup_preloader_true {
    width: 384px;
    height: 52px;
}

/* В коллауте ошибка вместо контента */
.leaflet-popup_error_true {
}

.leaflet-map-pane .leaflet-popup-tip-container {
    position: absolute;
    top: auto;
    bottom: 0;
    left: 50%;
    margin-left: -29px;
    width: 58px;
    height: 47px;
    background-repeat: no-repeat;
    transform: translateY(47px);
    pointer-events: none;
}

.leaflet-popup-tip {
    display: none;
}

.leaflet-popup-tip-container_svg {
    .notRepeatableBg('DGPopup__popupShadow', true);
    background-position: 50% 95%;
    background-size: 36px 12px;
}

.leaflet-container a.leaflet-popup-close-button {
    position: absolute;
    top: 3px;
    right: 3px;
    z-index: 1;
    overflow: hidden;
    padding: 0;
    width: 30px;
    height: 30px;
    text-align: center;
    font-weight: normal;
    font-size: 18px;
    line-height: 30px;
    cursor: pointer;

    .no-touch &:hover {
        border-radius: 2px;
        transition: all .2s;
    }

    &:active {
        color: #777777;
    }

    &:after {
        position: absolute;
        top: -3px;
        right: -5px;
        z-index: 2;
        width: 40px;
        height: 40px;
        content: '';
    }
}


================================================
FILE: src/DGPopup/skin/basic/less/scroller.less
================================================
.dg-scroller {
}

.dg-scroller_hidden_true {
    overflow: auto;
}

.dg-scroller::-webkit-scrollbar {
    width: 0;
}

.dg-scroller__wrapper {
    position: relative;
    overflow: hidden;
}

.dg-scroller__bar-wrapper {
    position: absolute;
    top: 18px;
    right: 3px;
    bottom: 4px;
    width: 7px;
    border-radius: 5px;
}

.dg-scroller_hidden_true .dg-scroller__bar-wrapper {
    visibility: hidden;
}

.dg-popup__header + .dg-popup__container-wrapper .dg-scroller__bar-wrapper {
    top: 4px;
}

.dg-scroller__bar {
    position: absolute;
    min-height: 20px;
    width: 7px;
    border-radius: 3px;
    pointer-events: auto;
}


================================================
FILE: src/DGPopup/skin/basic/skin.config.js
================================================
DG.configTheme = DG.configTheme || {};

DG.configTheme.balloonOptions = {
    offset: {
        x: 1,
        y: -43
    }
};


================================================
FILE: src/DGPopup/skin/dark/less/dg-popup.less
================================================
.leaflet-popup-scrolled .dg-popup__header:after,
.leaflet-popup-scrolled .dg-popup__footer:before {
    border-bottom: 1px solid #636363;
    background-color: #494949;
}


================================================
FILE: src/DGPopup/skin/dark/less/leaflet.ie.less
================================================
.leaflet-popup-content-wrapper {
    .opacity(.85);
    background-color: #323232;
}

.leaflet-oldie .leaflet-popup-content-wrapper {
    border: 0;
}


================================================
FILE: src/DGPopup/skin/dark/less/leaflet.less
================================================
.leaflet-popup-content-wrapper {
    background-color: rgba(50, 50, 50, .9);
}

.leaflet-popup-tip-container_image {
    .notRepeatableBg('DGPopup__popupShadow_dark', true);
}

.leaflet-map-pane .leaflet-popup-tip-container_svg {
    fill: rgba(50, 50, 50, .9);
}

.leaflet-container a.leaflet-popup-close-button {
    .no-touch &:hover {
        background-color: #222;
        box-shadow: 0 1px 3px rgba(0, 0, 0, .5);
    }

    &:after {
        top: -3px;
        right: -5px;
        width: 40px;
        height: 40px;
    }
}


================================================
FILE: src/DGPopup/skin/dark/less/scroller.less
================================================
.scroller__bar-wrapper .scroller__bar {
    background-color: #665b4f;
}

.scroller__bar-wrapper:hover .scroller__bar {
    background-color: #897a6b;
}


================================================
FILE: src/DGPopup/skin/light/less/dg-popup.less
================================================
.leaflet-popup-scrolled .dg-popup__header:after,
.leaflet-popup-scrolled .dg-popup__footer:before {
    background-color: #eee;
}


================================================
FILE: src/DGPopup/skin/light/less/leaflet.ie.less
================================================
.leaflet-popup-content-wrapper {
    .opacity(.95);
    background-color: #fff;
}

.leaflet-oldie .leaflet-popup-content-wrapper {
    border-color: #bebdb5;
}

.leaflet-map-pane .leaflet-popup-tip-container {
    bottom: -46px;
}


================================================
FILE: src/DGPopup/skin/light/less/leaflet.less
================================================
.leaflet-popup-content-wrapper {
    border: 1px solid #bebdb5;
    border-color: rgba(151, 151, 151, .6);
    background-color: rgba(255, 255, 255, .95);
    color: #000;
}

.leaflet-popup-tip-container_image {
    .notRepeatableBg('DGPopup__popupShadow_light', true);
}

.leaflet-map-pane .leaflet-popup-tip-container {
    transform: translateY(46px);
}

.leaflet-map-pane .leaflet-popup-tip-container_svg {
    margin-top: -2px;
    fill: rgba(255, 255, 255, .95);
    stroke: #bebdb5;
    stroke-dasharray: 0, 10, 100, 60;
}

.leaflet-container a.leaflet-popup-close-button {
    .no-touch &:hover {
        background-color: #f5faff;
        color: #6fa4d9;
    }

    &:after {
        top: -3px;
        right: -5px;
        width: 40px;
        height: 40px;
    }
}


================================================
FILE: src/DGPopup/skin/light/less/scroller.less
================================================
.scroller__bar-wrapper .scroller__bar {
    background-color: #eee;
}

.scroller__bar-wrapper:hover .scroller__bar {
    background-color: #c6c6c6;
}


================================================
FILE: src/DGPopup/src/DGPopup.js
================================================
require('../../../vendors/baron');

// 2GIS-related popup content wrapper and offset
(function() {
    var offsetX = DG.configTheme.balloonOptions.offset.x,
        offsetY = DG.configTheme.balloonOptions.offset.y,
        originalInitialize = DG.Popup.prototype.initialize,
        originalInitLayout = DG.Popup.prototype._initLayout,
        originalOnAdd = DG.Popup.prototype.onAdd,
        graf = baron.noConflict();

    var BaronDomHelper = function(element) {
        this[0] = element;
        this.length = 1;
    };
    BaronDomHelper.prototype = {
        setAttribute: function(name, value) {
            this[0].setAttribute(name, value);
            return this;
        },
        getAttribute: function(name) {
            return this[0].getAttribute(name);
        },
        removeAttribute: function(name) {
            this[0].removeAttribute(name);
            return this;
        },
        css: function(style, value) {
            if (value) {
                this[0].style[style] = value;
                return this;
            } else {
                return DG.DomUtil.getStyle(this[0], style);
            }
        }
    };

    DG.Popup.prototype.options.offset = DG.point(offsetX, offsetY);

    DG.Popup.mergeOptions({
        border: 16,
        mapControlsWidth: 60,
        textDirection: 'auto' // 'auto' | 'ltr' | 'rtl
    });

    DG.Popup.include({
        _headerContent: null,
        _footerContent: null,

        //baron elements references
        _scroller: null,
        _scrollerBar: null,
        _barWrapper: null,
        _baron: null,
        _isBaronExist: false,

        _popupShowClass: 'leaflet-popup_show_true',
        _popupHideClass: 'leaflet-popup_show_false',

        _popupTipClass: 'leaflet-popup-tip-container',
        _tipSVGPath: 'M0 0c12.643 0 28 7.115 28 44h2c0-36.885 15.358-44 28-44h-58z',

        _isAutoPanPaddingUserDefined: false,

        initialize: function(options, source) { // (Object, Object)
            this._popupStructure = {};
            this._isAutoPanPaddingUserDefined = options && options.hasOwnProperty('autoPanPadding');
            originalInitialize.call(this, options, source);
        },

        onAdd: function(map) { // (Map)
            map.on({
                entranceshow: this._closePopup,
                resize: this.resize
            }, this);
            originalOnAdd.call(this, map);
            this._animateOpening();
        },

        onRemove: function(map) { // (Map)
            this._animateClosing();
            map.off({
                entranceshow: this._closePopup,
                resize: this.resize
            }, this);

            if (DG.DomUtil.TRANSITION) {
                this._removeTimeout = setTimeout(L.bind(L.DomUtil.remove, L.DomUtil, this._container), 200);
            } else {
                L.DomUtil.remove(this._container);
            }

            map.fire('popupclose', {popup: this});

            if (this._source) {
                this._source.fire('popupclose', {popup: this}, true);
            }
        },

        setContent: function(content) { // (DOMElement | Object | HTML) -> Popup
            if (!this._isNode(content) && typeof content === 'object') {
                Object.keys(content).forEach(function(item) {
                    this['_' + item + 'Content'] = content[item];
                }, this);
            } else {
                this._bodyContent = content;
            }

            this.update();

            return this;
        },

        setHeaderContent: function(content) { // (HTML) -> Popup
            this._headerContent = content;
            this.update();

            return this;
        },

        setFooterContent: function(content) { // (HTML) -> Popup
            this._footerContent = content;
            this.update();

            return this;
        },

        getContent: function() { // () -> HTML
            return this._bodyContent;
        },

        getHeaderContent: function() { // () -> HTML
            return this._headerContent;
        },

        getFooterContent: function() { // () -> HTML
            return this._footerContent;
        },

        clear: function() { // () -> Popup
            Object.keys(this._popupStructure).forEach(this._clearElement, this);

            // think about move this set to another public method
            this._isBaronExist = false;
            return this;
        },

        clearHeader: function() { // () -> Popup
            return this._clearElement('header');
        },

        clearFooter: function() { // () -> Popup
            return this._clearElement('footer');
        },

        findElement: function(element) { // (String) -> DOMElement
            return this._contentNode.querySelector(element);
        },

        _animateOpening: function() {
            DG.DomUtil.addClass(this._innerContainer, this._popupShowClass);
            DG.DomUtil.removeClass(this._innerContainer, this._popupHideClass);
        },

        _animateClosing: function() {
            DG.DomUtil.addClass(this._innerContainer, this._popupHideClass);
            DG.DomUtil.removeClass(this._innerContainer, this._popupShowClass);
        },

        _closePopup: function() {
            this._map.closePopup(this);
        },

        _isNode: function(o) { // (Object) -> Boolean
            return (o.nodeName ? true : false);
        },

        _onCloseButtonClick: function(e) {
            if (this._map) {
                this._map.closePopup(this);
            }
            L.DomEvent.stop(e);
        },

        _close: function() {
            if (this._map) {
                if (DG.Browser.mobile && this._map.geoclicker &&
                    (this.options.closeOnClick || this._map.options.closePopupOnClick)) {
                    //  We need to signal geoclicker that popup was open before 'click' event
                    //  But by time it will get it's event the popup will be already closed
                    //  See 'DGGeoclicker' for '_mapEventsListeners' and '_singleClick' method
                    this._map.geoclicker.popupWasOpen = true;
                }

                this._map.closePopup(this);
            }
        },

        _initLayout: function() {
            originalInitLayout.call(this);

            // Prevents scroll events for div.leaflet-popup-content (this._contentNode) from web page scrolling when popup is opened
            DG.DomEvent.on(this._contentNode, 'wheel', function(e) {
                var eventPath;

                if (e.composedPath) {
                    eventPath = e.composedPath();
                } else {
                    var elem = e.target;
                    eventPath = [];
                    while (elem.parentNode) {
                        eventPath.push(elem);
                        elem = elem.parentNode;
                    }
                }

                if (eventPath.indexOf(this._scroller) === -1 || eventPath.indexOf(this._barWrapper) !== -1) {
                    e.preventDefault();
                }
            }, this);

            this._innerContainer = DG.DomUtil.create('div', 'leaflet-popup-inner ' + this._popupHideClass, this._container);

            // Prevents mouse events from leaking through close button
            // See https://github.com/2gis/mapsapi/pull/153/
            DG.DomEvent.disableClickPropagation(this._innerContainer);

            if (this.options.closeButton) {
                this._innerContainer.appendChild(this._detachEl(this._closeButton));
            }

            this._innerContainer.appendChild(this._detachEl(this._wrapper));

            var tip = this._detachEl(this._tipContainer);

            if (DG.Browser.svg) {
                var path = DG.SVG.create('path');
                var svgClass = this._popupTipClass + ' ' + this._popupTipClass + '_svg';

                path.setAttribute('d', this._tipSVGPath);

                tip = DG.SVG.create('svg');
                tip.setAttribute('class', svgClass);

                tip.appendChild(path);
                DG.DomEvent.disableClickPropagation(path);
            } else {
                DG.DomUtil.addClass(tip, this._popupTipClass + '_image');
                DG.DomEvent.disableClickPropagation(tip);
            }

            this._innerContainer.appendChild(tip);
        },

        _clearElement: function(elem) { // (DOMElement) -> Popup
            this['_' + elem + 'Content'] = null;
            this._detachEl(this._popupStructure[elem]);
            delete this._popupStructure[elem];
            return this;
        },

        _updateScrollPosition: function() {
            if (this._baron) {
                this._baron.update();
            }
        },

        resize: function() {
            var scrolled = this._updateLayout();
            this._updatePosition();

            if (!scrolled) {
                if (this._isBaronExist) {
                    this._scrollerWrapper.style.height = '';
                    DG.DomUtil.removeClass(this._scroller, 'dg-scroller');

                    DG.DomUtil.addClass(this._scroller, 'dg-scroller_hidden_true');
                    DG.DomUtil.removeClass(this._scroller, 'dg-scroller');
                    DG.DomEvent.off(this._scroller, 'scroll', this._onScroll);
                }
            } else if (this._isBaronExist) {
                DG.DomUtil.removeClass(this._scroller, 'dg-scroller_hidden_true');
                DG.DomUtil.addClass(this._scroller, 'dg-scroller');

                var scrollTop = this._isBaronExist ? this._scroller.scrollTop : false;

                if (scrollTop) {
                    this._scroller.scrollTop = scrollTop;
                }

                var innerHeight = this.options.maxHeight - this.options.border * 2 - this._getDelta();
                this._scrollerWrapper.style.height = innerHeight + 'px';

                this._updateScrollPosition();
            } else if (!this._isContentHeightEnough()) {
                this._initBaronScroller();
                this._initBaron();
            }

            this._adjustPan();
            this._bindAdjustPanOnTransitionEnd();
        },

        _adjustPan: function(e) {
            if (!this._map) { return; }

            if (e) { // animated popup is opening (height from 0 to max)
                if (e.propertyName === 'max-height') {
                    // when it's finished we are here
                    DG.DomEvent.off(this._wrapper, DG.DomUtil.TRANSITION_END, this._adjustPan);
                } else {
                    // here's intermediate steps - we don't need to process them
                    return;
                }
            }

            var options = this.options;

            if (!options.autoPan) { return; }

            var map = this._map,
                containerHeight = this._container.offsetHeight,
                containerWidth = this._containerWidth,
                layerPos = new L.Point(this._containerLeft, -containerHeight - this._containerBottom);

            if (this._zoomAnimated) {
                layerPos._add(L.DomUtil.getPosition(this._container));
            }

            var autoPanPadding = [options.autoPanPadding[0], options.autoPanPadding[1]];

            // if width of map is more then width of popup and controls
            // set default autoPanPadding to width controls
            if (
                !this._isAutoPanPaddingUserDefined &&
                    this._map._container.offsetWidth >= options.maxWidth + options.mapControlsWidth * 2
            ) {
                autoPanPadding[0] = options.mapControlsWidth;
            }

            var containerPos = map.layerPointToContainerPoint(layerPos),
                padding = L.point(autoPanPadding),
                paddingTL = L.point(options.autoPanPaddingTopLeft || padding),
                paddingBR = L.point(options.autoPanPaddingBottomRight || padding),
                size = map.getSize(),
                dx = 0,
                dy = 0;

            if (size.x === 0 || size.y === 0) {
                // map isn't visible
                return;
            }

            if (containerPos.x + containerWidth + paddingBR.x > size.x) { // right
                dx = containerPos.x + containerWidth - size.x + paddingBR.x;
            }
            if (containerPos.x - dx - paddingTL.x < 0) { // left
                dx = containerPos.x - paddingTL.x;
            }
            if (containerPos.y + containerHeight + paddingBR.y > size.y) { // bottom
                dy = containerPos.y + containerHeight - size.y + paddingBR.y;
            }
            if (containerPos.y - dy - paddingTL.y < 0) { // top
                dy = containerPos.y - paddingTL.y;
            }

            if (dx || dy) {
                map
                    .fire('autopanstart')
                    .panBy([dx, dy]);
            }
        },

        _bindAdjustPanOnTransitionEnd: function() {
            if (DG.DomUtil.TRANSITION) {
                DG.DomEvent.on(this._wrapper, DG.DomUtil.TRANSITION_END, this._adjustPan, this);
            } else {
                this._adjustPan();
            }
        },

        _isContentHeightEnough: function() { // () -> Boolean
            var options = this.options;

            if (!options.maxHeight) {
                return true;
            }

            var popupHeight = this._popupStructure.body ?
                this._popupStructure.body.offsetHeight + this._getDelta() :
                this._contentNode.offsetHeight;

            popupHeight += options.border * 2;

            return popupHeight <= options.maxHeight;
        },

        _initBaronScroller: function() {
            var contentNode = this._popupStructure.body.parentNode,
                scrollerWrapper = this._scrollerWrapper = DG.DomUtil.create('div', 'dg-scroller__wrapper', contentNode),
                scroller = this._scroller = DG.DomUtil.create('div', 'dg-scroller', scrollerWrapper),
                barWrapper = this._barWrapper = DG.DomUtil.create('div', 'dg-scroller__bar-wrapper', scroller),
                innerHeight = this.options.maxHeight - this.options.border * 2;

            this._scrollerBar = DG.DomUtil.create('div', 'dg-scroller__bar', barWrapper);
            scroller.appendChild(this._detachEl(this._popupStructure.body));

            innerHeight -= this._getDelta();
            scrollerWrapper.style.height = Math.max(18, innerHeight) + 'px';
            scrollerWrapper.style.width = contentNode.offsetWidth + 5 + 'px'; //TODO

            this._isBaronExist = true;

            this._switchEvents();
        },

        _onScroll: function(e) {
            this.fire('scroll', {originalEvent: e});
        },

        _onClick: function(e) {
            e.target = e.target || e.srcElement;

            if (!this._moving) {
                this.fire('click', {originalEvent: e});
            }
        },

        _onStart: function(e) {
            this._moved = false;

            if (this._moving) { return; }

            var first = e.touches ? e.touches[0] : e;

            this._startPoint = new DG.Point(first.clientX, first.clientY);

            this._toggleTouchEvents();
        },

        _onEnd: function(e) {
            this._toggleTouchEvents(true);

            this._onClick(e);

            this._moving = false;
        },

        _onMove: function(e) {

            if (e.touches && e.touches.length > 1) {
                this._moved = true;
                return;
            }

            var first = (e.touches && e.touches.length === 1 ? e.touches[0] : e),
                newPoint = DG.point(first.clientX, first.clientY),
                offset = Math.abs(newPoint.subtract(this._startPoint).y);

            if (!offset || offset < 10) { return; }

            this._moving = this._moved = true;

        },

        _initBaron: function() {
            var context = this._scrollerWrapper;
            this._baron = graf({
                scroller: '.dg-scroller',
                bar: '.dg-scroller__bar',
                track: '.dg-scroller__bar-wrapper',
                $: function(selector) {
                    var node = {}.toString.call(selector) === '[object String]' ?
                        context.querySelector(selector) : selector;

                    return new BaronDomHelper(node);
                },
                event: function(elem, event, func, mode) {
                    event.split(' ').forEach(function(type) {
                        DG.DomEvent[mode || 'on'](elem, type, func);
                    });
                }
            });
        },

        _initHeader: function() {
            this._popupStructure.header = DG.DomUtil.create('header', 'dg-popup__header', this._contentNode);
            this._popupStructure.header.setAttribute('dir', this.options.textDirection);
        },

        _initFooter: function() {
            this._popupStructure.footer = DG.DomUtil.create('footer', 'dg-popup__footer', this._contentNode);
            this._popupStructure.footer.setAttribute('dir', this.options.textDirection);
        },

        _initBodyContainer: function() {
            this._popupStructure.wrapper = DG.DomUtil.create('div', 'dg-popup__container-wrapper', this._contentNode);
            this._popupStructure.body = DG.DomUtil.create('div', 'dg-popup__container', this._popupStructure.wrapper);
            this._popupStructure.body.setAttribute('dir', this.options.textDirection);
        },

        update: function() {
            if (!this._map) { return; }

            if (!DG.Browser.ielt9) {
                this._container.style.visibility = 'hidden';
            }
            this._switchEvents(true);

            this._clearNode(this._contentNode);
            this._isBaronExist = false;

            // init popup content dom structure
            if (this._headerContent) { this._initHeader(); }
            if (this._bodyContent) { this._initBodyContainer(); }
            if (this._footerContent) { this._initFooter(); }

            this._updatePopupStructure();
            this.resize();

            DG.DomEvent.on(this._wrapper, 'click', DG.DomEvent.stopPropagation);
            this._switchEvents();

            if (DG.Browser.ielt9) {
                var elem = this._popupStructure.footer;
                if (elem) {
                    elem.className += ' ie8';
                }
            }

            if (!DG.Browser.ielt9) {
                this._container.style.visibility = '';
            }
        },

        _getDelta: function() { // () -> Number
            var delta = 0,
                popup = this._popupStructure;

            if (popup.header) {
                delta += popup.header.offsetHeight;
            }
            if (popup.footer) {
                delta += popup.footer.offsetHeight;
            }

            return delta;
        },

        _updateLayout: function() {
            var opts = this.options,
                content = this._contentNode, // leaflet-popup-content
                wrapper = this._wrapper, // leaflet-popup-content-wrapper
                style = content.style,
                wrapperStyle = wrapper.style,
                width,
                scrolledClass = 'leaflet-popup-scrolled',
                result = false;

            style.margin = opts.border + 'px';

            DG.DomUtil.removeClass(content, scrolledClass);

            if (this._isContentHeightEnough()) {
                wrapperStyle.maxHeight = content.offsetHeight + opts.border * 2 + 'px';
            } else {
                wrapperStyle.maxHeight = opts.maxHeight + 'px';
                DG.DomUtil.addClass(content, scrolledClass);
                result = true;
            }

            var availableWidth = opts.autoPanPadding[0] * 2;

            if (opts.sprawling) {
                width = opts.maxWidth;

                width = Math.min(width, this._map._container.offsetWidth - availableWidth);
                width = Math.max(width, opts.minWidth);
            } else {
                wrapperStyle.width = '';

                style.whiteSpace = 'nowrap';
                width = wrapper.offsetWidth;
                style.whiteSpace = '';

                width = Math.min(width, this._map._container.offsetWidth - availableWidth);
                width = Math.min(Math.max(width, opts.minWidth), opts.maxWidth);
            }

            wrapperStyle.width = width + 'px';

            this._containerWidth = this._container.offsetWidth;

            return result;
        },

        _updatePopupStructure: function() {
            Object.keys(this._popupStructure).forEach(function(item) {
                this._insertContent(this['_' + item + 'Content'], this._popupStructure[item]);
            }, this);

            this.fire('contentupdate');
        },

        _insertContent: function(content, node) { // (String | DOMElement, DOMElement)
            if (!content || !node) { return; }

            content = (typeof content === 'function') ? content(this._source || this) : content;

            if (typeof content === 'string') {
                node.innerHTML = content;
            } else {
                this._clearNode(node);
                node.appendChild(content);
            }
        },

        _clearNode: function(node) { // (DOMElement)
            while (node.hasChildNodes()) {
                node.removeChild(node.firstChild);
            }
        },

        _detachEl: function(elem) { // (DOMElement) -> DOMElement
            if (elem.parentNode) {
                elem.parentNode.removeChild(elem);
            }
            return elem;
        },

        _switchEvents: function(on) { // (Boolean)
            var switcher = on ? 'off' : 'on';

            if (!DG.Browser.touch) {
                DG.DomEvent[switcher](this._contentNode, 'click', this._onClick, this);
            } else {
                DG.DomEvent[switcher](this._contentNode, 'touchstart mousedown mousemove', this._onStart, this);
            }

            if (this._isBaronExist) {
                DG.DomEvent[switcher](this._scroller, 'scroll', this._onScroll, this);
            }
        },

        _toggleTouchEvents: function(on) {
            var switcher = on ? 'off' : 'on';

            DG.DomEvent[switcher](this._contentNode, 'touchmove', this._onMove, this);
            DG.DomEvent[switcher](this._contentNode, 'touchend', this._onEnd, this);
        }

    });
}());


DG.Map.include({
    _markerClass: 'dg-customization__marker_type_mushroom',
    _markerShowClass: 'dg-customization__marker_appear',
    _markerHideClass: 'dg-customization__marker_disappear',
    _dgHideClass: 'dg-popup_hidden_true',
    openPopup: function(popup, latlng, options) { // (Popup) or (String || HTMLElement, LatLng[, Object])
        if (!(popup instanceof L.Popup)) {
            var content = popup;

            popup = new L.Popup(options).setContent(content);
        }

        if (latlng) {
            popup.setLatLng(latlng);
        }

        if (this.hasLayer(popup)) {
            return this;
        }

        if (this._popup && this._popup.options.autoClose) {
            this.closePopup();
        }

        this._popup = popup;

        if (popup._source && popup._source._icon) {
            if (popup._source._icon.className.indexOf(this._markerClass) !== -1) {
                DG.DomUtil.removeClass(popup._source._icon, this._markerShowClass);
                DG.DomUtil.addClass(popup._source._icon, this._markerHideClass);
            } else {
                DG.DomUtil.addClass(popup._source._icon, this._dgHideClass);
                if (popup._source._shadow) {
                    DG.DomUtil.addClass(popup._source._shadow, this._dgHideClass);
                }
            }
        }

        return this.addLayer(popup);
    },

    closePopup: function(popup) {  // (Popup) -> Popup
        if (!popup || popup === this._popup) {
            popup = this._popup;
            this._popup = null;
        }
        if (popup) {
            if (popup._source && popup._source._icon) {
                if (popup._source._icon.className.indexOf(this._markerClass) !== -1) {
                    DG.DomUtil.removeClass(popup._source._icon, this._markerHideClass);
                    DG.DomUtil.addClass(popup._source._icon, this._markerShowClass);
                } else {
                    DG.DomUtil.removeClass(popup._source._icon, this._dgHideClass);
                    if (popup._source._shadow) {
                        DG.DomUtil.removeClass(popup._source._shadow, this._dgHideClass);
                    }
                }
            }
            this.removeLayer(popup);
        }

        return this;
    }
});


================================================
FILE: src/DGPopup/test/DGPopupSpec.js
================================================
describe('DG.Popup', function() {
    var map,
        mapContainer,
        shortString = 'qwerty',
        longString = (new Array(15)).join('1<br>'),

        classPopupBodyContainer = 'dg-popup__container',
        classPopupHeaderContainer = 'dg-popup__header',
        classPopupFooterContainer = 'dg-popup__footer',
        classScrollBar = 'dg-scroller__bar';

    before(function () {
        mapContainer = document.createElement('div');
        document.body.appendChild(mapContainer);

        map = new DG.Map(mapContainer, {
            center: [54.980206086231, 82.898068362003],
            zoom: 15,
            key: window.__karma__.config.secretKey,
        });
    });

    after(function() {
        map.remove();
        mapContainer.parentElement.removeChild(mapContainer);
        mapContainer = map = shortString = longString = classPopupBodyContainer = classPopupHeaderContainer = classPopupFooterContainer = classScrollBar = null;
    });

    describe('check contents', function() {
        var popup;

        beforeEach(function() {
            popup = DG.popup({maxHeight: 100})
                .setLatLng([54.980206086231, 82.898068362003])
                .addTo(map);
        });

        afterEach(function() {
            popup.clear();
            popup.remove();
        });

        describe('#setContent', function() {
            it('should change popup content without scroll', function() {
                popup.setContent(shortString);
                expect(mapContainer.getElementsByClassName(classPopupBodyContainer)[0].innerHTML).to.be(shortString);
                expect(mapContainer.getElementsByClassName(classScrollBar).length).to.be(0);
            });

            it('should change popup content with scroll', function() {
                popup.setContent(longString);
                expect(mapContainer.getElementsByClassName(classPopupBodyContainer)[0].innerHTML).to.be(longString);
                expect(mapContainer.getElementsByClassName(classScrollBar).length).to.be(1);
            });
        });

        describe('#getContent', function() {
            it('should get eql content', function() {
                popup.setContent(shortString);

                expect(popup.getContent()).to.be(shortString);
            });
        });

        describe('#setHeaderContent', function() {
            it('should change popup header content', function() {
                popup.setContent(shortString);
                popup.setHeaderContent(shortString);
                expect(mapContainer.getElementsByClassName(classPopupHeaderContainer)[0].innerHTML).to.be(shortString);
            });

            it('should be scroll in popup', function() {
                popup.setContent(shortString);
                popup.setHeaderContent(longString);
                expect(mapContainer.getElementsByClassName(classScrollBar).length).to.be(1);
            });
        });

        describe('#getHeaderContent', function() {
            it('should get eql header content', function() {
                popup.setHeaderContent(shortString);

                expect(popup.getHeaderContent()).to.be(shortString);
            });
        });

        describe('#setFooterContent', function() {
            it('should change popup footer content', function() {
                popup.setContent(shortString);
                popup.setFooterContent(shortString);
                expect(mapContainer.getElementsByClassName(classPopupFooterContainer)[0].innerHTML).to.be(shortString);
            });

            it('should be scroll in popup', function() {
                popup.setContent(shortString);
                popup.setFooterContent(longString);
                expect(mapContainer.getElementsByClassName(classScrollBar).length).to.be(1);
            });
        });

        describe('#getFooterContent', function() {
            it('should get eql footer content', function() {
                popup.setFooterContent(shortString);

                expect(popup.getFooterContent()).to.be(shortString);
            });
        });
    });

    describe('check events', function() {
        var popup;

        before(function() {
            popup = DG.popup({maxHeight: 100})
                .setLatLng([54.980206086231, 82.898068362003])
                .setContent(longString)
                .addTo(map);
        });

        after(function() {
            popup.remove();
        });

        it.skip('should call click event', function() {
            var spy = sinon.spy();

            popup.on('click', spy);

            happen.click(popup._contentNode);

            expect(spy.called).to.be.ok();
        });

        it('should call scroll event', function() {
            var spy = sinon.spy();

            popup.on('scroll', spy);

            happen.once(mapContainer.getElementsByClassName(classPopupBodyContainer)[0], {
                type: 'scroll'
            });

            expect(spy.called).to.be.ok();
        });
    });

    // TODO: дописать остальные тесты после фикса https://github.com/2gis/mapsapi/issues/44
});

//  Modified tests from PopupSpec.js
describe('L.Popup', function () {

    var c, map;

    beforeEach(function () {
        c = document.createElement('div');
        c.style.width = '400px';
        c.style.height = '400px';
        document.body.appendChild(c);
        map = new L.Map(c);
        map.setView(new L.LatLng(55.8, 37.6), 6);
    });

    afterEach(function () {
        document.body.removeChild(c);
    });

    it("it should use a popup with a function as content with a FeatureGroup", function () {
        var marker1 = new L.Marker(new L.LatLng(55.8, 37.6));
        var marker2 = new L.Marker(new L.LatLng(54.6, 38.2));
        var group = new L.FeatureGroup([marker1, marker2]).addTo(map);

        marker1.description = "I'm marker 1.";
        marker2.description = "I'm marker 2.";
        group.bindPopup(function (layer) {
            return layer.description;
        });

        map.options.closePopupOnClick = true;

        // toggle popup on marker1
        group.fire('click', {
            latlng: new L.LatLng(55.8, 37.6),
            layer: marker1
        });
        expect(map.hasLayer(group._popup)).to.be(true);
        expect(group._popup._contentNode.firstElementChild.firstElementChild.innerHTML).to.be("I'm marker 1.");

        // toggle popup on marker2
        group.fire('click', {
            latlng: new L.LatLng(54.6, 38.2),
            layer: marker2
        });
        expect(map.hasLayer(group._popup)).to.be(true);
        expect(group._popup._contentNode.firstElementChild.firstElementChild.innerHTML).to.be("I'm marker 2.");
    });

    it("it should function for popup content after bindPopup is called", function () {
        var marker1 = new L.Marker(new L.LatLng(55.8, 37.6));
        var marker2 = new L.Marker(new L.LatLng(54.6, 38.2));
        var group = new L.FeatureGroup([marker1]).addTo(map);

        marker1.description = "I'm marker 1.";
        marker2.description = "I'm marker 2.";
        group.bindPopup(function (layer) {
            return layer.description;
        });

        group.addLayer(marker2);

        map.options.closePopupOnClick = true;

        // toggle popup on marker1
        group.fire('click', {
            latlng: new L.LatLng(55.8, 37.6),
            layer: marker1
        });
        expect(map.hasLayer(group._popup)).to.be(true);
        expect(group._popup._contentNode.firstElementChild.firstElementChild.innerHTML).to.be("I'm marker 1.");

        // toggle popup on marker2
        group.fire('click', {
            latlng: new L.LatLng(54.6, 38.2),
            layer: marker2
        });
        expect(map.hasLayer(group._popup)).to.be(true);
        expect(group._popup._contentNode.firstElementChild.firstElementChild.innerHTML).to.be("I'm marker 2.");
    });

    it("should use a function for popup content when a source is passed to Popup", function () {
        var marker = new L.Marker(new L.LatLng(55.8, 37.6)).addTo(map);
        var popup = L.popup({}, marker);

        marker.description = "I am a marker.";

        marker.bindPopup(function (layer) {
            return layer.description;
        });

        marker.fire('click', {
            latlng: new L.LatLng(55.8, 37.6)
        });

        expect(map.hasLayer(marker._popup)).to.be(true);
        expect(marker._popup._contentNode.firstElementChild.firstElementChild.innerHTML).to.be("I am a marker.");
    });
});


================================================
FILE: src/DGProjectDetector/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <title>projectDetector demo</title>
    <meta charset="utf-8"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>
</head>
<body>

<div id="map" style="width: 100%; height: 600px; border: 1px solid #ccc;"></div>

<script type="text/javascript">
    DG.then(function () {

        var currentProjectBound,
            map = new DG.Map('map', {
                center:new DG.LatLng(54.980206086231, 82.898068362003),
                zoom:10,
                key: DG.config.key || 'Your API access key'
            });

        map.on('projectchange', function (e) {
            // projectchange event
            var bounds = e.getProject().latLngBounds;
            currentProjectBound = DG.rectangle(bounds, {color:"#f03", weight:1}).addTo(map);
        });

        map.on('projectleave', function (e) {
            // projectleave event
            if (currentProjectBound) {
                currentProjectBound.onRemove(map);
            }
        });

    });
</script>

</body>
</html>


================================================
FILE: src/DGProjectDetector/src/DGProjectDetector.js
================================================
DG.ProjectDetector = DG.Handler.extend({
    initialize: function(map) { // (Object)
        this._map = map;
        this._project = undefined;
        this._loadProjectList();
    },

    addHooks: function() {
        this._projectWatch();
        this._map.on('move', this._projectWatch, this);
    },

    removeHooks: function() {
        this._map.off('move', this._projectWatch, this);
    },

    getProject: function() {
        if (!this._project) { return false; }

        return DG.Util.extend({}, this._project);
    },

    getProjectsList: function() {
        return this._projectList.slice(0);
    },

    isProjectHere: function(coords, project, checkMethod) {
        if (!coords) { return null; }

        if (!(coords instanceof DG.LatLng) && !(coords instanceof DG.LatLngBounds)) {
            coords = DG.latLng(coords);
        }

        coords = (coords instanceof DG.LatLngBounds) ?
            DG.latLngBounds(coords.getSouthWest().wrap(), coords.getNorthEast().wrap()) : coords.wrap();

        checkMethod = checkMethod || ((coords instanceof DG.LatLngBounds) ?  'intersects' : 'contains');

        var method = checkMethod == 'intersects' ? this._testProjectIntersects : this._testProjectContains;
        method = method.bind(this, coords);

        if (project) {
            return method(project);
        } else {
            return this._projectList.filter(method)[0];
        }
    },

    _projectWatch: function() {
        if (!this._map._loaded) {
            return;
        }

        if (this._project && this._zoomInProject(this._project) && this._centerInProject(this._project)) {
            return;
        }

        this._searchProject();

        if (this._project) {
            this._map.attributionControl._update(null, this._project.country_code);
        }
    },

    _checkProjectData: function(project) {
        function check(value) {
            return value !== undefined && value !== null;
        }

        return project &&
                project.bounds &&
                check(project.code) &&
                check(project.domain) &&
                check(project.country_code) &&
                check(project.flags) &&
                project.zoom_level &&
                    check(project.zoom_level.min) &&
                    check(project.zoom_level.max) &&
                project.time_zone &&
                    check(project.time_zone.offset);
    },

    _loadProjectList: function() {
        DG.fallbackProjectsList = DG.fallbackProjectsList || [];

        if (!DG.projectsList) {
            DG.projectsList = DG.fallbackProjectsList;
        }
        delete DG.fallbackProjectsList;

        this._projectList = DG.projectsList
            .filter(this._checkProjectData)
            .map(function(project) {
                var bound = DG.Wkt.toGeoJSON(project.bounds);
                var latLngBounds = DG.geoJSON(bound).getBounds();
                var defaultPos = project.default_pos ? DG.latLng(project.default_pos.lat, project.default_pos.lon) : null;


                /* eslint-disable camelcase */
                return {
                    id: project.id,
                    code: project.code,
                    minZoom: project.zoom_level.min,
                    maxZoom: project.zoom_level.max,
                    timeOffset: project.time_zone.offset,
                    bound: bound,
                    latLngBounds: latLngBounds,
                    traffic: !!project.flags.traffic,
                    transport: !!project.flags.public_transport,
                    roads: !!project.flags.road_network,
                    country_code: project.country_code,
                    domain: project.domain,
                    defaultPos: defaultPos
                };
                /* eslint-enable camelcase */
            });
    },

    _searchProject: function() {
        // Вначале отсеиваем регионы по зуму
        var filteredByZoom = this._projectList.filter(this._zoomInProject, this);

        // Находим проект в границы которого попадает центр карты
        var foundProjects = filteredByZoom.filter(this._centerInProject, this);

        // Если такой проект не найден, то ищем проекты баунд боксы которых пересекаются с экраном
        if (foundProjects.length === 0) {
            var mapBounds = this._map.getBounds();
            foundProjects = filteredByZoom.filter(DG.bind(this._testProjectIntersects, this, mapBounds));

            if (foundProjects.length > 1) {
                var mapCenter = this._map.getCenter();
                var neareastProject = foundProjects[0];
                for (var i = 1; i < foundProjects.length; i++) {
                    var currentProject = foundProjects[i];
                    if (currentProject.defaultPos &&
                        mapCenter.distanceTo(neareastProject.defaultPos) >
                        mapCenter.distanceTo(currentProject.defaultPos)
                    ) {
                        neareastProject = currentProject;
                    }
                }
                foundProjects = [neareastProject];
            }
        }

        var newProject = foundProjects[0] || null;

        if (this._project === newProject) {
            return;
        }

        var self = this;

        if (this._project !== null) {
            this._project = null;
            setTimeout(function() {
                self._map.fire('projectleave');
            }, 1);
        }

        if (newProject) {
            this._project = newProject;
            setTimeout(function() {
                self._map.fire('projectchange', {getProject: self.getProject.bind(self)});
            }, 1);
        }
    },

    _testProjectIntersects: function(bounds, project) {
        return project.latLngBounds.intersects(bounds);
    },

    _testProjectContains: function(latlng, project) {
        return DG.PolyUtil.inside([latlng.lng, latlng.lat], project.bound);
    },

    _centerInProject: function(project, checkMethod) {
        return this.isProjectHere(this._map.getCenter(), project, checkMethod);
    },

    _zoomInProject: function(project) {
        return (this._map.getZoom() >= project.minZoom);
    }
});

DG.Map.mergeOptions({
    projectDetector: true
});

DG.Map.addInitHook('addHandler', 'projectDetector', DG.ProjectDetector);


================================================
FILE: src/DGProjectDetector/test/ProjectDetectorInSpec.js
================================================
describe('DG.ProjectDetectorIn', function () {
    var map,
        mapContainer,
        initZoom = 17,
        maxZoom = 18,
        maxDesertZoom = 16,
        start,
        project1,
        project2,
        desert1,
        desert2;

    before(function () {
        mapContainer = document.createElement('div');

        start =        new DG.LatLng(54.98117239821992, 82.88922250270844);

        // Где-то где есть проект
        project1 =     new DG.LatLng(54.97902673261798, 82.819265127182);
        project2 =     new DG.LatLng(54.98620210307464, 73.41429233551025);

        // Где-то в лесу, там где нет проекта
        desert1 =      new DG.LatLng(59.56, 86.32);
        desert2 =      new DG.LatLng(65.38, 87.39);

        document.body.appendChild(mapContainer);
        mapContainer.style.width = 1900 + 'px';
        mapContainer.style.height = 600 + 'px';
    });

    after(function() {
        document.body.removeChild(mapContainer);
        mapContainer = initZoom = maxZoom = maxDesertZoom = start = project1 = null;
        project2 = desert1 = desert2 = null;
    });

    beforeEach(function () {
        map = new DG.Map(mapContainer, {
            center: start,
            key: window.__karma__.config.secretKey,
            'zoom': initZoom,
            'geoclicker': true,
            'zoomAnimation': false
        });
    });

    afterEach(function () {
        map.remove();
        map = null;
    });

    describe('#setView', function () {

        it('go to from project to project', function () {
            expect(map.setView(project1, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to from desert to project', function () {
            map.setView(desert1, maxZoom, {animate: false});
            expect(map.setView(project1, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to from project1 to project2', function () {
            map.setView(project1, maxZoom);

            expect(map.setView(project2, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project2);
        });

        it('go to from project to desert', function () {
            map.setView(project1, maxZoom);

            expect(map.setView(desert1, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);
        });

        it('go to from desert1 to desert2', function () {
            map.setView(desert1, maxDesertZoom, {animate: false});

            expect(map.setView(desert2, maxDesertZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert2);
        });

    });

    describe('#setZoom', function () {

        it('go to 18 zoom level in desert', function () {
            map.setView(desert1, maxDesertZoom);

            map.setZoom(maxZoom);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);
        });

        it('go to 18 zoom level from 0', function () {
            map.setView(project1, 0);

            map.setZoom(maxZoom);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to 0 zoom level from 18', function () {
            map.setView(project1, maxZoom);

            map.setZoom(0);
            expect(map.getZoom()).to.be(0);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to max zoom level + 1', function () {
            map.setZoom(map.getMaxZoom() + 1);
            expect(map.getZoom()).to.be(map.getMaxZoom());
        });

        it('go to min zoom level - 1', function () {
            map.setZoom(map.getMinZoom() - 1);
            expect(map.getZoom()).to.be(map.getMinZoom());
        });
    });

    describe('#zoomIn', function () {

        it('call on maxZoom', function () {
            map.setView(desert1, maxDesertZoom);

            expect(map.zoomIn()).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
        });

        it('call on 16 level', function () {
            map.setView(desert1, 10);

            expect(map.zoomIn()).to.be(map);
            expect(map.getZoom()).to.be(11);
        });

    });

    describe('#zoomOut', function () {

        it('call on minZoom', function () {
            map.setView(desert1, 0);

            expect(map.zoomOut()).to.be(map);
            expect(map.getZoom()).to.be(0);
        });

        it('call on 16 level', function () {
            map.setView(desert1, 10);

            expect(map.zoomOut()).to.be(map);
            expect(map.getZoom()).to.be(9);
        });

    });

    describe('#setZoomAround', function () {

        it('zoom to other project', function () {
            map.setView(project1, 17);

            expect(map.setZoomAround(project2, maxZoom)).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
        });

        it('zoom in the project', function () {
            map.setView(start, 13);

            expect(map.setZoomAround(project1, maxZoom)).to.be(map);
            expect(map.getBounds().contains(project1)).to.be.ok();
            expect(map.getZoom()).to.be(maxZoom);
        });
    });

    describe('#fitBounds', function () {

        it('bound on project1 from project1 small zoom', function () {
            map.setView(project1, 8);

            expect(map.fitBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

        it('bound on project1 from project2 small zoom', function () {
            map.setView(project2, 8);

            expect(map.fitBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

        it('bound on small square from project1 zero zoom', function () {
            map.setZoomAround(L.latLng(56.68037378950137, 89.4287109375), 4);

            expect(map.fitBounds([[54.98116931987221, 82.8987979888916], [54.97977172563573, 82.8981113433837]])).to.be(map);
            expect(map.getZoom()).to.be(18);
        });
    });

    describe('#fitWorld', function () {

        it('fire from max zoom', function () {
            map.setView(project1, maxZoom);

            expect(map.fitWorld()).to.be(map);
            expect(map.getZoom()).to.be(1);
        });

        it('fire from min zoom', function () {
            map.setView(project1, 0);

            expect(map.fitWorld()).to.be(map);
            expect(map.getZoom()).to.be(1);
        });

        it('fire after min zoom 15', function () {
            map.setZoom(15);

            expect(map.fitWorld()).to.be(map);
            expect(map.getZoom()).to.be(1);
        });
    });

    describe('#panTo', function () {

        it('fire on project2 from project1', function () {
            map.setView(project1, 16);

            expect(map.panTo(project2)).to.be(map);
            expect(map.getZoom()).to.be(16);
            expect(map.getCenter()).to.be.equal(project2);
        });

        it('fire on desert from project1 max zoom', function () {
            map.setView(project1, maxZoom);

            expect(map.panTo(desert1)).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);
        });

        it('fire on project1 from desert', function () {
            map.setView(desert1, maxDesertZoom);

            expect(map.panTo(project1)).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('fire on project1 from project1', function () {
            map.setView(start, 15);

            expect(map.panTo(project1, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(15);
            expect(map.getCenter().distanceTo(project1)).to.be.below(15);
        });
    });

    describe('#panInsideBounds', function () {

        it('bound on project1 from project2', function () {
            map.setView(project2, 15);

            expect(map.panInsideBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

        it('bound on project1 from desert', function () {
            map.setView(desert1, maxDesertZoom);

            expect(map.panInsideBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
        });

        it('bound on project1 from project1 small zoom', function () {
            map.setView(project1, 15);

            expect(map.panInsideBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

    });

    describe('#panBy', function () {

        it('call with viewport size', function () {
            map.setView(project1, 16);

            expect(map.panBy([1901, 601], {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(16);
            expect(map.getCenter()).to.nearLatLng(DG.latLng(54.971628386497684, 82.86006689071657));
        });

        it('call on project viewport', function () {
            map.setView(project1, maxZoom);

            expect(map.panBy([100, -200]), {animate: false}).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.nearLatLng(DG.latLng(54.97964243031826, 82.819801568985), 10e-4);
        });

    });

    describe('#MaxZoom in options', function () {

        it('set less max project zoom and zoom to 20 in project', function () {
            map.options.maxZoom = 16;
            expect(map.getMaxZoom()).to.be.equal(16);

            map.setView(project1, 20);

            expect(map.getZoom()).to.be.equal(16);
        });

        it('set less max project zoom and zoom to 20 in desert', function () {
            map.options.maxZoom = 16;
            expect(map.getMaxZoom()).to.be.equal(16);

            map.setView(desert1, 20);

            expect(map.getZoom()).to.be.equal(maxDesertZoom);
        });

        it('set more max project zoom and zoom to 20 in project', function () {
            map.options.maxZoom = 19;
            expect(map.getMaxZoom()).to.be.equal(19);

            map.setView(project1, 20);

            expect(map.getZoom()).to.be.equal(19);
        });

        it('set more max project zoom and zoom to 20 in desert', function () {
            map.options.maxZoom = 19;
            expect(map.getMaxZoom()).to.be.equal(19);

            map.setView(desert1, 20);

            expect(map.getZoom()).to.be.equal(maxDesertZoom);
        });

        it('set max zoom, go to from project to desert and back to the project', function () {
            map.options.maxZoom = 16;
            expect(map.getMaxZoom()).to.be.equal(16);
            map.setView(project1, maxZoom, {animate: false});

            expect(map.setView(desert1, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);

            expect(map.setView(project1, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(16);
            expect(map.getCenter()).to.be.equal(project1);
        });

    });

    describe('#multiLayers', function () {
        var cloudmade2;
        beforeEach(function () {
            function getCloudMadeUrl(styleId) {
                return 'http://{s}.tile.cloudmade.com/d4fc77ea4a63471cab2423e66626cbb6/' + styleId + '/256/{z}/{x}/{y}.png';
            }
            cloudmade2 = DG.tileLayer(getCloudMadeUrl(998), {attribution: 'Hello world', minZoom: 5, maxZoom: 18}).addTo(map);
        });

        afterEach(function () {
            map.removeLayer(cloudmade2);
        });

        it('zoom to 18 in desert with added layer', function () {
            map.setView(desert1, maxZoom);

            expect(map.getZoom()).to.be.equal(maxZoom);
        });

        it('zoom to 18 in desert with remove layer', function () {
            map.removeLayer(cloudmade2);
            map.setView(desert1, maxZoom);

            expect(map.getZoom()).to.be.equal(maxDesertZoom);
        });

        it('zoom to 18 in desert with remove 2gis tilelayer', function () {
            map.removeLayer(map.baseLayer);
            map.setView(desert1, maxZoom);

            expect(map.getZoom()).to.be.equal(maxZoom);
        });
    });

    describe('#isProjectHere', function () {

        it('without params', function () {
            expect(map.projectDetector.isProjectHere()).to.not.be.ok();
        });

        it('in desert', function () {
            expect(map.projectDetector.isProjectHere(desert1)).to.not.be.ok();
        });

        it('in project', function () {
            expect(map.projectDetector.isProjectHere(project1)).to.have.property('latLngBounds');
            expect(map.projectDetector.isProjectHere(project1).code).to.be.eql('novosibirsk');
        });
    });

    describe('#should fire', function () {
        it('\'projectchange\' event', function (done) {
            var onProjectChange = function () {
                map.off('projectchange', onProjectChange);
                done();
            };
            map.on('projectchange', onProjectChange);
            map.setView(project2, maxZoom);
        });

        it('\'projectleave\' event', function (done) {
            var onProjectLeave = function () {
                map.off('projectleave', onProjectLeave);
                done();
            };
            map.on('projectleave', onProjectLeave);
            map.setView(desert1, maxZoom);
        });
    });
});


================================================
FILE: src/DGProjectDetector/test/ProjectDetectorInitSpec.js
================================================
describe('DG.ProjectDetectorInit', function () {
    var map,
        mapContainer,
        maxZoom = 18,
        maxDesertZoom = 16,
        project1,
        desert1;

    before(function () {
        mapContainer = document.createElement('div');

        // Где-то где есть проект
        project1 = new DG.LatLng(54.97902673261798, 82.819265127182);

        // Где-то в лесу, там где нет проекта
        desert1 = new DG.LatLng(59.56, 86.32);

        document.body.appendChild(mapContainer);
        mapContainer.style.width = 1900 + 'px';
        mapContainer.style.height = 600 + 'px';
    });

    after(function() {
        document.body.removeChild(mapContainer);
        map = mapContainer = maxZoom = maxDesertZoom = project1 = desert1 = null;
    });

    describe('#initMap', function () {

        afterEach(function () {
            map.remove();
            map = null;
        });

        it('in project', function () {
            map = new DG.Map(mapContainer, {
                center: project1,
                key: window.__karma__.config.secretKey,
                'zoom': 19,
                'geoclicker': true,
                'zoomAnimation': false
            });
            expect(map.getZoom()).to.be.equal(maxZoom);
        });

        it('in desert', function () {
            map = new DG.Map(mapContainer, {
                center: desert1,
                key: window.__karma__.config.secretKey,
                'zoom': 19,
                'geoclicker': true,
                'zoomAnimation': false
            });
            expect(map.getZoom()).to.be.equal(maxDesertZoom);
        });

        it('in project with max zoom', function () {
            map = new DG.Map(mapContainer, {
                center: project1,
                key: window.__karma__.config.secretKey,
                'zoom': 19,
                'maxZoom': 15,
                'geoclicker': true,
                'zoomAnimation': false
            });
            expect(map.getZoom()).to.be.equal(15);
        });

        it('in desert with max zoom', function () {
            map = new DG.Map(mapContainer, {
                center: desert1,
                key: window.__karma__.config.secretKey,
                'zoom': 19,
                'maxZoom': 15,
                'geoclicker': true,
                'zoomAnimation': false
            });
            expect(map.getZoom()).to.be.equal(maxDesertZoom);
        });

        it('without options', function () {
            map = new DG.Map(mapContainer).setView([0, 0], 0);
            expect(map.getCenter()).to.be.eql({lat: 0, lng: 0});
        });

    });
});


================================================
FILE: src/DGProjectDetector/test/ProjectDetectorOutOfWorldSpec.js
================================================
describe('DG.ProjectDetectorOut', function () {
    var map,
        mapContainer,
        initZoom = 17,
        maxZoom = 18,
        maxDesertZoom = 16,
        start,
        project1,
        project2,
        desert1,
        desert2;

    before(function () {
        mapContainer = document.createElement('div');

        start =        new DG.LatLng(54.98117239821992, 360 + 82.88922250270844);

        // Где-то где есть проект
        project1 =     new DG.LatLng(54.97902673261798, 360 + 82.819265127182);
        project2 =     new DG.LatLng(54.98620210307464, 360 + 73.41429233551025);

        // Где-то в лесу, там где нет проекта
        desert1 =      new DG.LatLng(59.56, 360 + 86.32);
        desert2 =      new DG.LatLng(65.38, 360 + 87.39);

        document.body.appendChild(mapContainer);
        mapContainer.style.width = 1900 + 'px';
        mapContainer.style.height = 600 + 'px';
    });

    after(function() {
        document.body.removeChild(mapContainer);
        mapContainer = initZoom = maxZoom = maxDesertZoom = start = project1 = null;
        project2 = desert1 = desert2 = null;
    });

    beforeEach(function () {
        map = new DG.Map(mapContainer, {
            center: start,
            key: window.__karma__.config.secretKey,
            'zoom': initZoom,
            'geoclicker': true,
            'zoomAnimation': false
        });
    });

    afterEach(function () {
        map.remove();
        map = null;
    });

    describe('#setView', function () {

        it('go to from project to project', function () {
            expect(map.setView(project1, maxZoom)).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to from desert to project', function () {
            map.setView(desert1, maxZoom);
            expect(map.setView(project1, maxZoom)).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to from project1 to project2', function () {
            map.setView(project1, maxZoom);

            expect(map.setView(project2)).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project2);
        });

        it('go to from project to desert', function () {
            map.setView(project1, maxZoom, {animate: false});

            expect(map.setView(desert1, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);
        });

        it('go to from desert1 to desert2', function () {
            map.setView(desert1, maxDesertZoom);

            expect(map.setView(desert2)).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert2);
        });

    });

    describe('#setZoom', function () {

        it('go to 18 zoom level in desert', function () {
            map.setView(desert1, maxDesertZoom);

            map.setZoom(maxZoom);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);
        });

        it('go to 18 zoom level from 0', function () {
            map.setView(project1, 0);

            map.setZoom(maxZoom);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to 0 zoom level from 18', function () {
            map.setView(project1, maxZoom);

            map.setZoom(0);
            expect(map.getZoom()).to.be(0);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to max zoom level + 1', function () {
            map.setZoom(map.getMaxZoom() + 1);
            expect(map.getZoom()).to.be(map.getMaxZoom());
        });

        it('go to min zoom level - 1', function () {
            map.setZoom(map.getMinZoom() - 1);
            expect(map.getZoom()).to.be(map.getMinZoom());
        });
    });

    describe('#zoomIn', function () {

        it('call on maxZoom', function () {
            map.setView(desert1, maxDesertZoom);

            expect(map.zoomIn()).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
        });

        it('call on 16 level', function () {
            map.setView(desert1, 10);

            expect(map.zoomIn()).to.be(map);
            expect(map.getZoom()).to.be(11);
        });

    });

    describe('#zoomOut', function () {

        it('call on minZoom', function () {
            map.setView(desert1, 0);

            expect(map.zoomOut()).to.be(map);
            expect(map.getZoom()).to.be(0);
        });

        it('call on 16 level', function () {
            map.setView(desert1, 10);

            expect(map.zoomOut()).to.be(map);
            expect(map.getZoom()).to.be(9);
        });

    });

    describe('#setZoomAround', function () {

        it('zoom to other project', function () {
            map.setView(project1, 17);

            expect(map.setZoomAround(project2, maxZoom)).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
        });

        it('zoom in the project', function () {
            map.setView(start, 13);

            expect(map.setZoomAround(project1, maxZoom)).to.be(map);
            expect(map.getBounds().contains(project1)).to.be.ok();
            expect(map.getZoom()).to.be(maxZoom);
        });
    });

    describe('#fitBounds', function () {

        it('bound on project1 from project1 small zoom', function () {
            map.setView(project1, 8);

            expect(map.fitBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

        it('bound on project1 from project2 small zoom', function () {
            map.setView(project2, 8);

            expect(map.fitBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

        it('bound on small square from project1 zero zoom', function () {
            map.setZoomAround(L.latLng(56.68037378950137, 89.4287109375), 4);

            expect(map.fitBounds([[54.98116931987221, 82.8987979888916], [54.97977172563573, 82.8981113433837]])).to.be(map);
            expect(map.getZoom()).to.be(18);
        });
    });

    describe('#fitWorld', function () {

        it('fire from max zoom', function () {
            map.setView(project1, maxZoom);

            expect(map.fitWorld()).to.be(map);
            expect(map.getZoom()).to.be(1);
        });

        it('fire from min zoom', function () {
            map.setView(project1, 0);

            expect(map.fitWorld()).to.be(map);
            expect(map.getZoom()).to.be(1);
        });

        it('fire after min zoom 15', function () {
            map.setZoom(15);

            expect(map.fitWorld()).to.be(map);
            expect(map.getZoom()).to.be(1);
        });
    });

    describe('#panTo', function () {

        it('fire on project2 from project1', function () {
            map.setView(project1, 16);

            expect(map.panTo(project2)).to.be(map);
            expect(map.getZoom()).to.be(16);
            expect(map.getCenter()).to.be.equal(project2);
        });

        it('fire on desert from project1 max zoom', function () {
            map.setView(project1, maxZoom);

            expect(map.panTo(desert1)).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);
        });

        it('fire on project1 from desert', function () {
            map.setView(desert1, maxDesertZoom);

            expect(map.panTo(project1)).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('fire on project1 from project1', function () {
            map.setView(start, 15);

            expect(map.panTo(project1, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(15);
            expect(map.getCenter().distanceTo(project1)).to.be.below(15);
        });
    });

    describe('#panInsideBounds', function () {

        it('bound on project1 from project2', function () {
            map.setView(project2, 15);

            expect(map.panInsideBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

        it('bound on project1 from desert', function () {
            map.setView(desert1, maxDesertZoom);

            expect(map.panInsideBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
        });

        it('bound on project1 from project1 small zoom', function () {
            map.setView(project1, 15);

            expect(map.panInsideBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

    });

    describe('#panBy', function () {

        it('call with viewport size', function () {
            map.setView(project1, 16);

            expect(map.panBy([1901, 601]), {animate: false}).to.be(map);
            expect(map.getZoom()).to.be(16);
            expect(map.getCenter()).to.nearLatLng(DG.latLng(54.971628386497684, 442.8600454330445));
        });

        it('call on project viewport', function () {
            map.setView(project1, maxZoom);

            expect(map.panBy([100, -200], {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.nearLatLng(DG.latLng(54.97964243031826, 442.8198015689851));
        });

    });

    describe('#MaxZoom in options', function () {

        it('set less max project zoom and zoom to 20 in project', function () {
            map.options.maxZoom = 16;
            expect(map.getMaxZoom()).to.be.equal(16);

            map.setView(project1, 20);

            expect(map.getZoom()).to.be.equal(16);
        });

        it('set less max project zoom and zoom to 20 in desert', function () {
            map.options.maxZoom = 16;
            expect(map.getMaxZoom()).to.be.equal(16);

            map.setView(desert1, 20);

            expect(map.getZoom()).to.be.equal(maxDesertZoom);
        });

        it('set more max project zoom and zoom to 20 in project', function () {
            map.options.maxZoom = 19;
            expect(map.getMaxZoom()).to.be.equal(19);

            map.setView(project1, 20);

            expect(map.getZoom()).to.be.equal(19);
        });

        it('set more max project zoom and zoom to 20 in desert', function () {
            map.options.maxZoom = 19;
            expect(map.getMaxZoom()).to.be.equal(19);

            map.setView(desert1, 20);

            expect(map.getZoom()).to.be.equal(maxDesertZoom);
        });

        it('set max zoom, go to from project to desert and back to the project', function () {
            map.options.maxZoom = 16;
            expect(map.getMaxZoom()).to.be.equal(16);
            map.setView(project1, maxZoom, {animate: false});

            expect(map.setView(desert1, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);

            expect(map.setView(project1, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(16);
            expect(map.getCenter()).to.be.equal(project1);
        });

    });

    describe('#multiLayers', function () {
        var cloudmade2;
        beforeEach(function () {
            function getCloudMadeUrl(styleId) {
                return 'http://{s}.tile.cloudmade.com/d4fc77ea4a63471cab2423e66626cbb6/' + styleId + '/256/{z}/{x}/{y}.png';
            }
            cloudmade2 = DG.tileLayer(getCloudMadeUrl(998), {attribution: 'Hello world', minZoom: 5, maxZoom: 18}).addTo(map);
        });

        afterEach(function () {
            map.removeLayer(cloudmade2);
        });

        it('zoom to 18 in desert with added layer', function () {
            map.setView(desert1, maxZoom);

            expect(map.getZoom()).to.be.equal(maxZoom);
        });

        it('zoom to 18 in desert with remove layer', function () {
            map.removeLayer(cloudmade2);
            map.setView(desert1, maxZoom);

            expect(map.getZoom()).to.be.equal(maxDesertZoom);
        });

        it('zoom to 18 in desert with remove 2gis tilelayer', function () {
            map.removeLayer(map.baseLayer);
            map.setView(desert1, maxZoom);

            expect(map.getZoom()).to.be.equal(maxZoom);
        });
    });

    describe('#isProjectHere', function () {

        it('without params', function () {
            expect(map.projectDetector.isProjectHere()).to.not.be.ok();
        });

        it('in desert', function () {
            expect(map.projectDetector.isProjectHere(desert1)).to.not.be.ok();
        });

        it('in project', function () {
            expect(map.projectDetector.isProjectHere(project1)).to.have.property('latLngBounds');
            expect(map.projectDetector.isProjectHere(project1).code).to.be.eql('novosibirsk');
        });
    });

    describe('#should fire', function () {
        it('\'projectchange\' event', function (done) {
            var onProjectChange = function () {
                map.off('projectchange', onProjectChange);
                done();
            };
            map.on('projectchange', onProjectChange);
            map.setView(project2, maxZoom);
        });

        it('\'projectleave\' event', function (done) {
            var onProjectLeave = function () {
                map.off('projectleave', onProjectLeave);
                done();
            };
            map.on('projectleave', onProjectLeave);
            map.setView(desert1, maxZoom);
        });
    });
});


================================================
FILE: src/DGProjectDetector/test/ProjectDetectorUnderSpec.js
================================================
describe('DG.ProjectDetectorUnder', function () {
    var map,
        mapContainer,
        initZoom = 1,
        maxZoom = 18,
        maxDesertZoom = 16,
        start,
        project1,
        project2,
        desert1,
        desert2;

    before(function () {
        mapContainer = document.createElement('div');

        start =        new DG.LatLng(54.98117239821992, 82.88922250270844);

        // Где-то где есть проект
        project1 =     new DG.LatLng(54.97902673261798, 82.819265127182);
        project2 =     new DG.LatLng(54.98620210307464, 73.41429233551025);

        // Где-то в лесу, там где нет проекта
        desert1 =      new DG.LatLng(59.56, 86.32);
        desert2 =      new DG.LatLng(65.38, 87.39);

        document.body.appendChild(mapContainer);
        mapContainer.style.width = 1900 + 'px';
        mapContainer.style.height = 600 + 'px';
    });

    after(function () {
        document.body.removeChild(mapContainer);
        mapContainer = initZoom = maxZoom = maxDesertZoom = start = project1 = null;
        project2 = desert1 = desert2 = null;
    });

    beforeEach(function () {
        map = new DG.Map(mapContainer, {
            center: start,
            key: window.__karma__.config.secretKey,
            'zoom': initZoom,
            'geoclicker': true,
            'zoomAnimation': false
        });
    });

    afterEach(function () {
        map.remove();
        map = null;
    });

    describe('#setView', function () {

        it('go to from project to project', function () {
            expect(map.setView(project1, maxZoom)).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to from desert to project', function () {
            map.setView(desert1, maxZoom);
            expect(map.setView(project1, maxZoom)).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to from project1 to project2', function () {
            map.setView(project1, maxZoom);

            expect(map.setView(project2)).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project2);
        });

        it('go to from project to desert', function () {
            map.setView(project1, maxZoom, {animate: false});

            expect(map.setView(desert1, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);
        });

        it('go to from desert1 to desert2', function () {
            map.setView(desert1, maxDesertZoom);

            expect(map.setView(desert2)).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert2);
        });

    });

    describe('#setZoom', function () {

        it('go to 18 zoom level in desert', function () {
            map.setView(desert1, maxDesertZoom);

            map.setZoom(maxZoom);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);
        });

        it('go to 18 zoom level from 0', function () {
            map.setView(project1, 0);

            map.setZoom(maxZoom);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to 0 zoom level from 18', function () {
            map.setView(project1, maxZoom);

            map.setZoom(0);
            expect(map.getZoom()).to.be(0);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('go to max zoom level + 1', function () {
            map.setZoom(map.getMaxZoom() + 1);
            expect(map.getZoom()).to.be(map.getMaxZoom());
        });

        it('go to min zoom level - 1', function () {
            map.setZoom(map.getMinZoom() - 1);
            expect(map.getZoom()).to.be(map.getMinZoom());
        });
    });

    describe('#zoomIn', function () {

        it('call on maxZoom', function () {
            map.setView(desert1, maxDesertZoom);

            expect(map.zoomIn()).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
        });

        it('call on 16 level', function () {
            map.setView(desert1, 10);

            expect(map.zoomIn()).to.be(map);
            expect(map.getZoom()).to.be(11);
        });

    });

    describe('#zoomOut', function () {

        it('call on minZoom', function () {
            map.setView(desert1, 0);

            expect(map.zoomOut()).to.be(map);
            expect(map.getZoom()).to.be(0);
        });

        it('call on 16 level', function () {
            map.setView(desert1, 10);

            expect(map.zoomOut()).to.be(map);
            expect(map.getZoom()).to.be(9);
        });

    });

    describe('#setZoomAround', function () {

        it('zoom to other project', function () {
            map.setView(project1, 17);

            expect(map.setZoomAround(project2, maxZoom)).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
        });

        it('zoom in the project', function () {
            map.setView(start, 13);

            expect(map.setZoomAround(project1, maxZoom)).to.be(map);
            expect(map.getBounds().contains(project1)).to.be.ok();
            expect(map.getZoom()).to.be(maxZoom);
        });
    });

    describe('#fitBounds', function () {
        it('bound on project1 from project1 small zoom', function () {
            map.setView(project1, 8);

            expect(map.fitBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

        it('bound on project1 from project2 small zoom', function () {
            map.setView(project2, 8);

            expect(map.fitBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

        it('bound on small square from project1 zero zoom', function () {
            map.setZoomAround(L.latLng(56.68037378950137, 89.4287109375), 4);

            expect(map.fitBounds([[54.98116931987221, 82.8987979888916], [54.97977172563573, 82.8981113433837]])).to.be(map);
            expect(map.getZoom()).to.be(18);
        });
    });

    describe('#fitWorld', function () {

        it('fire from max zoom', function () {
            map.setView(project1, maxZoom);

            expect(map.fitWorld()).to.be(map);
            expect(map.getZoom()).to.be(1);
        });

        it('fire from min zoom', function () {
            map.setView(project1, 0);

            expect(map.fitWorld()).to.be(map);
            expect(map.getZoom()).to.be(1);
        });

        it('fire after min zoom 15', function () {
            map.setZoom(15);

            expect(map.fitWorld()).to.be(map);
            expect(map.getZoom()).to.be(1);
        });
    });

    describe('#panTo', function () {

        it('fire on project2 from project1', function () {
            map.setView(project1, 16);

            expect(map.panTo(project2)).to.be(map);
            expect(map.getZoom()).to.be(16);
            expect(map.getCenter()).to.be.equal(project2);
        });

        it('fire on desert from project1 max zoom', function () {
            map.setView(project1, maxZoom);

            expect(map.panTo(desert1)).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);
        });

        it('fire on project1 from desert', function () {
            map.setView(desert1, maxDesertZoom);

            expect(map.panTo(project1)).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(project1);
        });

        it('fire on project1 from project1', function () {
            map.setView(start, 15);

            expect(map.panTo(project1, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(15);
            expect(map.getCenter().distanceTo(project1)).to.be.below(15);
        });
    });

    describe('#panInsideBounds', function () {

        it('bound on project1 from project2', function () {
            map.setView(project2, 15);

            expect(map.panInsideBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

        it('bound on project1 from desert', function () {
            map.setView(desert1, maxDesertZoom);

            expect(map.panInsideBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
        });

        it('bound on project1 from project1 small zoom', function () {
            map.setView(project1, 15);

            expect(map.panInsideBounds(new DG.LatLngBounds(project1, start))).to.be(map);
            expect(map.getZoom()).to.be(15);
        });

    });

    describe('#panBy', function () {

        it('call with viewport size', function () {
            map.setView(project1, 16);

            expect(map.panBy([1901, 601], {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(16);
            expect(map.getCenter()).to.nearLatLng(DG.latLng(54.971628386497684, 82.86006689071657));
        });

        it('call on project viewport', function () {
            map.setView(project1, maxZoom);

            expect(map.panBy([100, -200], {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxZoom);
            expect(map.getCenter()).to.nearLatLng(DG.latLng(54.97964243031826, 82.819801568985));
        });

    });

    describe('#MaxZoom in options', function () {

        it('set less max project zoom and zoom to 20 in project', function () {
            map.options.maxZoom = 16;
            expect(map.getMaxZoom()).to.be.equal(16);

            map.setView(project1, 20);

            expect(map.getZoom()).to.be.equal(16);
        });

        it('set less max project zoom and zoom to 20 in desert', function () {
            map.options.maxZoom = 16;
            expect(map.getMaxZoom()).to.be.equal(16);

            map.setView(desert1, 20);

            expect(map.getZoom()).to.be.equal(maxDesertZoom);
        });

        it('set more max project zoom and zoom to 20 in project', function () {
            map.options.maxZoom = 19;
            expect(map.getMaxZoom()).to.be.equal(19);

            map.setView(project1, 20);

            expect(map.getZoom()).to.be.equal(19);
        });

        it('set more max project zoom and zoom to 20 in desert', function () {
            map.options.maxZoom = 19;
            expect(map.getMaxZoom()).to.be.equal(19);

            map.setView(desert1, 20);

            expect(map.getZoom()).to.be.equal(maxDesertZoom);
        });

        it('set max zoom, go to from project to desert and back to the project', function () {
            map.options.maxZoom = 16;
            expect(map.getMaxZoom()).to.be.equal(16);
            map.setView(project1, maxZoom, {animate: false});

            expect(map.setView(desert1, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(maxDesertZoom);
            expect(map.getCenter()).to.be.equal(desert1);

            expect(map.setView(project1, maxZoom, {animate: false})).to.be(map);
            expect(map.getZoom()).to.be(16);
            expect(map.getCenter()).to.be.equal(project1);
        });

    });

    describe('#multiLayers', function () {
        var cloudmade2;
        beforeEach(function () {
            function getCloudMadeUrl(styleId) {
                return 'http://{s}.tile.cloudmade.com/d4fc77ea4a63471cab2423e66626cbb6/' + styleId + '/256/{z}/{x}/{y}.png';
            }
            cloudmade2 = DG.tileLayer(getCloudMadeUrl(998), {attribution: 'Hello world', minZoom: 5, maxZoom: 18}).addTo(map);
        });

        afterEach(function () {
            map.removeLayer(cloudmade2);
        });

        it('zoom to 18 in desert with added layer', function () {
            map.setView(desert1, maxZoom);

            expect(map.getZoom()).to.be.equal(maxZoom);
        });

        it('zoom to 18 in desert with remove layer', function () {
            map.removeLayer(cloudmade2);
            map.setView(desert1, maxZoom);

            expect(map.getZoom()).to.be.equal(maxDesertZoom);
        });

        it('zoom to 18 in desert with remove 2gis tilelayer', function () {
            map.removeLayer(map.baseLayer);
            map.setView(desert1, maxZoom);

            expect(map.getZoom()).to.be.equal(maxZoom);
        });
    });

    describe('#isProjectHere', function () {
        it('without params', function () {
            expect(map.projectDetector.isProjectHere()).to.not.be.ok();
        });

        it('in desert', function () {
            expect(map.projectDetector.isProjectHere(desert1)).to.not.be.ok();
        });

        it('in project', function () {
            expect(map.projectDetector.isProjectHere(project1)).to.have.property('latLngBounds');
            expect(map.projectDetector.isProjectHere(project1).code).to.be.eql('novosibirsk');
        });
    });

    describe('#should fire', function () {
        it('\'projectchange\' event', function (done) {
            var onProjectChange = function () {
                map.off('projectchange', onProjectChange);
                done();
            };
            map.on('projectchange', onProjectChange);
            map.setView(project2, maxZoom);
        });

        it('\'projectleave\' event', function (done) {
            var onProjectLeave = function () {
                map.off('projectleave', onProjectLeave);
                done();
            };
            map.on('projectleave', onProjectLeave);
            map.setView(desert1, maxZoom);
        });
    });
});


================================================
FILE: src/DGRoundControl/skin/basic/less/dg-control-round.less
================================================
.dg-control-round {
    position: relative;
    padding: 5px;
    width: 30px;
    height: 30px;
    border-radius: 50%;
    cursor: default;
}

.dg-control-round__icon {
    position: relative;
    display: block;
    width: 30px;
    height: 30px;
    border-radius: 50%;
    background-color: #f0f0f0; // 94%, fallback
    background-image: linear-gradient(to bottom, #fff 0, hsl(0, 0%, 88%) 100%);
    color: #2b2a29;
    text-align: center;
    text-decoration: none;
    text-shadow: 0 1px 0 #fff;
    font-size: 22px;
    line-height: 30px;
    cursor: pointer;

    .no-touch &:hover {
        background-color: #f5f5f5; // 96%, fallback
        background-image: linear-gradient(to bottom, hsl(0, 0%, 92%) 0, #fff 100%);
    }

    &:active,
    .no-touch &:active,
    &_state_active {
        background-color: #ebebeb; // 92%, fallback
        background-image: linear-gradient(to bottom, hsl(0, 0%, 84%) 0, #fff 100%);
    }

    .leaflet-disabled &,
    .no-touch .leaflet-disabled &:hover,
    .leaflet-disabled &:active {
        background-image: none;
        cursor: default;
    }

    .leaflet-touch &:before {
        position: absolute;
        top: -10px;
        right: -15px;
        bottom: -10px;
        left: -15px;
        content: '';
    }
}

.dg-control-round_is-hidden_true {
    display: none;
}


================================================
FILE: src/DGRoundControl/skin/dark/less/dg-control-round.less
================================================
.dg-control-round {
    background-color: #3d3d3d; // 24%
    box-shadow: 0 3px 5px 0 rgba(0, 0, 0, .3);
}

.dg-control-round__icon {
    box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .4);

    .no-touch &:hover {
        box-shadow: inset 0 1px #fff, 0 0 0 1px rgba(0, 0, 0, .3), 0 1px 0 1px rgba(0, 0, 0, .4);
    }

    &:active,
    .no-touch &:active,
    &_state_active {
        box-shadow: inset 0 1px 1px 1px rgba(0, 0, 0, .2), 0 0 0 1px rgba(0, 0, 0, .3), 0 -1px 1px 0 #000;
    }

    .leaflet-disabled &,
    .no-touch .leaflet-disabled &:hover,
    .leaflet-disabled &:active {
        background-color: #b8b8b8; // 72%
        box-shadow: none;
    }
}


================================================
FILE: src/DGRoundControl/skin/light/less/dg-control-round.less
================================================
.dg-control-round {
    background-color: #f0f0f0; // 94%
    box-shadow: 0 0 0 1px #fff, 0 2px 5px 0 rgba(0, 0, 0, .3);
}

.dg-control-round__icon {
    box-shadow: 0 0 1px 0 rgba(0, 0, 0, .4);

    .leaflet-disabled &,
    .no-touch .leaflet-disabled &:hover,
    .leaflet-disabled &:active {
        background-color: #e0e0e0; // 88%
    }

    .leaflet-disabled & {
        box-shadow: none;
    }
}


================================================
FILE: src/DGRoundControl/src/DGRoundControl.js
================================================
DG.RoundControl = DG.Control.extend({
    includes: DG.Mixin.Events,

    options: {
        position: 'topright',
        iconClass: 'default'
    },

    onAdd: function(map) {
        var controlClass = this._controlCLass = 'dg-control-round',
            controlIconClass = this._controlIconCLass = this._controlCLass + '__icon',
            container = DG.DomUtil.create('div', '');

        if (this._disable) {
            return container;
        }
        DG.DomUtil.addClass(container, controlClass);

        var link = this._link = DG.DomUtil.create(
            'a',
            controlIconClass + ' ' + controlIconClass + '_name_' + this.options.iconClass,
            container
        );

        link.href = '#';

        this._renderTranslation();

        this._map = map;

        DG.DomEvent
            .on(container, 'click', this._toggleControl, this)
            .on(container, 'dblclick', DG.DomEvent.stopPropagation)
            .on(link, 'mousedown', DG.DomEvent.stopPropagation);

        this.fireEvent('add');

        return container;
    },

    onRemove: function() {
        this.fireEvent('remove');
        DG.DomEvent.off(this._link, 'click', this._toggleControl);
    },

    setState: function(state) {
        if (!this._link || !this._container) {
            return this;
        }

        if (this._state) {
            DG.DomUtil.removeClass(this._container, this._controlCLass + '_state_' + this._state);
            DG.DomUtil.removeClass(this._link, this._controlIconCLass + '_state_' + this._state);

            this._state = null;
        }

        if (state) {
            this._state = state;

            DG.DomUtil.addClass(this._container, this._controlCLass + '_state_' + this._state);
            DG.DomUtil.addClass(this._link, this._controlIconCLass + '_state_' + this._state);
        }

        return this;
    },

    _toggleControl: function(e) {
        DG.DomEvent.stop(e);
        this.fireEvent('click');
    }
});

DG.RoundControl.include(DG.Locale);

DG.roundControl = function(options) {
    return new DG.RoundControl(options);
};


================================================
FILE: src/DGRoundControl/test/DGRoundControlSpec.js
================================================
describe('DG.RoundControl', function() {
    var map, mapContainer, control, classIconControl, classActive, containerControl, spy;

    before(function() {
        classIconControl = 'dg-control-round__icon_name_default';
        classActive = 'dg-control-round__icon_state_active';

        mapContainer = document.createElement('div');
        document.body.appendChild(mapContainer);

        map = new DG.Map(mapContainer, {
            center: [55.017493, 82.819576],
            zoom: 15,
            key: window.__karma__.config.secretKey,
        });

        control = DG.roundControl();
    });

    after(function() {
        mapContainer.parentElement.removeChild(mapContainer);
        map.remove();
        map = mapContainer = control = classIconControl = classActive = containerControl = spy = null;
    });

    describe('#addTo', function() {
        before(function() {
            spy = sinon.spy();
            control.on('add', spy);
            control.addTo(map);
        });

        after(function() {
            spy = null;
        });

        it('should container control on map', function() {
            containerControl = document.body.getElementsByClassName(classIconControl);
            expect(containerControl.length).to.be(1);
            containerControl = containerControl[0];
        });

        it('should emit add event', function() {
            expect(spy.calledOnce).to.be.ok();
        });

        // TODO: включить после фикса leaflet'а с добавлением нескольких контейнеров для одного контрола
        it.skip('should only one container for one control', function() {
            control.addTo(map);
            expect(document.body.getElementsByClassName(classIconControl).length).to.be(1);
        });

        it('should emit click event', function() {
            var spy = sinon.spy();
            control.on('click', spy);
            happen.click(containerControl);
            expect(spy.callCount).to.be(1);
        });
    });

    describe('#setState', function() {
        it('should container have active class', function() {
            control.setState('active');
            expect(containerControl.className).to.contain(classActive);
        });

        it('should container haven\'t active class and have \'someclass\'', function() {
            control.setState('someclass');
            expect(containerControl.className).not.contain(classActive);
            expect(containerControl.className).to.contain('someclass');
        });

        it('should container haven\' someclass', function() {
            control.setState();
            expect(containerControl.className).not.contain('someclass');
        });
    });

    describe('#remove', function() {
        before(function() {
            spy = sinon.spy();
            control.on('remove', spy);
            control.remove();
        });

        after(function() {
            spy = null;
        });

        it('should remove container on map', function() {
            expect(document.body.getElementsByClassName(classIconControl).length).to.be(0);
        });

        it('should emit remove event', function() {
            expect(spy.calledOnce).to.be.ok();
        });

        it('shouldn\'t emit click event', function() {
            var spy = sinon.spy();
            control.on('click', spy);
            happen.click(containerControl);
            expect(spy.called).not.be.ok();
        });
    });
});


================================================
FILE: src/DGRuler/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>
    <title>DGRuler demo</title>
    <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>
    <style type="text/css">
        html,body { height: 100%; margin: 0; padding: 0; }
        #map { width: 100%; height: 100%; }
    </style>
</head>
<body>
    <div id="map"></div>
    <script type="text/javascript">
        DG.then(function () {
            map = new DG.Map('map', {
                'center': new DG.LatLng(51.73028, 36.19389),
                'zoom': 17,
                key: DG.config.key || 'Your API access key'
            });

            var latLngs = [
                [51.7314, 36.1938],
                [51.7307, 36.1894],
                [51.7297, 36.1926],
                [51.7299, 36.1968],
                [51.7307, 36.1968]]
            DG.ruler(latLngs).addTo(map);
        });
    </script>
</body>
</html>


================================================
FILE: src/DGRuler/lang/ar.js
================================================
DG.Ruler.Dictionary.ar = {
    km : 'كم',
    m : 'م',
    delimiter : '.'
};


================================================
FILE: src/DGRuler/lang/cs.js
================================================
DG.Ruler.Dictionary.cs = {
    km: 'km',
    m: 'm',
    delimiter: ','
};


================================================
FILE: src/DGRuler/lang/en.js
================================================
DG.Ruler.Dictionary.en = {
    km : 'km',
    m : 'm',
    delimiter : '.'
};


================================================
FILE: src/DGRuler/lang/es.js
================================================
DG.Ruler.Dictionary.es = {
    km : 'km',
    m : 'm',
    delimiter : ','
};


================================================
FILE: src/DGRuler/lang/it.js
================================================
DG.Ruler.Dictionary.it = {
    km : 'km',
    m : 'm',
    delimiter : ','
};


================================================
FILE: src/DGRuler/lang/ru.js
================================================
DG.Ruler.Dictionary.ru = {
    km : 'км',
    m : 'м',
    delimiter : ','
};


================================================
FILE: src/DGRuler/skin/basic/less/dg-ruler.ie.less
================================================
.dg-ruler__point {
    .repeatableBg('DGRuler__point');
}

.dg-ruler__label-container {
    background: #0da5d5;
}


================================================
FILE: src/DGRuler/skin/basic/less/dg-ruler.less
================================================
.leaflet-rulerMarker-pane {
    z-index: 600;
}

.dg-ruler__label {
    position: absolute;
    top: 0;
    left: 0;
    z-index: 200;
    -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
}

.dg-ruler__label-spacer {
    display: block;
}

.dg-ruler__label-container {
    display: none;
    padding: 2px 4px;
    border: 4px solid #fff;
    border-radius: 13px;
    background: #0da5d5;
    background-clip: padding-box;
    color: #fff;
    white-space: nowrap;
    font-size: 12px;
}

.dg-ruler__point {
    display: inline-block;
    margin: 2px 4px 0 0;
    width: 10px;
    height: 10px;
    border-radius: 5px;
    background: white;
}

.dg-ruler__label-remove-link {
    .notRepeatableBgWithSizes('DGRuler__removeIcon');
    display: none;
    margin: 1px 0 0 4px;
    vertical-align: top;
    transition: all .2s ease;

    .no-touch &:hover {
        transform: rotate(90deg);
    }
}

.dg-ruler__remove-link-overlay {
    position: absolute;
    top: -7px;
    right: -7px;
    bottom: -7px;
    width: 40px;

    .no-touch & {
        display: none;
    }
}


================================================
FILE: src/DGRuler/src/GeometryStyles.js
================================================
var rulerRenderer = DG.svg({pane: 'rulerPane'});
var hoverRenderer = DG.svg({pane: 'rulerPane'});

DG.Ruler.mergeOptions({
    pathStyles: {
        back: {
            color: '#fff',
            opacity: 1,
            weight: 12,
            pointerEvents: 'none',
            noClip: true,
            renderer: rulerRenderer,
            smoothFactor: 0
        },
        middle: {
            color: '#0da5d5',
            opacity: 1,
            weight: 4,
            pointerEvents: 'none',
            noClip: true,
            renderer: rulerRenderer,
            smoothFactor: 0
        },
        mouse: {
            color: '#fff',
            opacity: DG.Browser.vml ? 0.1 : 0,
            weight: DG.Browser.touch ? 40 : 20,
            pointerEvents: 'painted',
            noClip: true,
            renderer: hoverRenderer,
            smoothFactor: 0
        }
    },
    iconStyles: {
        large: {
            back: {
                color: '#fff',
                opacity: 1,
                fillColor: '#fff',
                fillOpacity: 1,
                weight: 1,
                radius: 13,
                renderer: rulerRenderer
            },
            middle: {
                color: '#0da5d5',
                opacity: 1,
                fillColor: '#0da5d5',
                fillOpacity: 1,
                weight: 1,
                radius: 9,
                renderer: rulerRenderer
            },
            front: {
                color: '#fff',
                opacity: 1,
                fillColor: '#0da5d5',
                fillOpacity: 1,
                weight: 4,
                radius: 5,
                renderer: rulerRenderer
            }
        },
        small: {
            back: {
                color: '#fff',
                opacity: 1,
                fillColor: '#fff',
                fillOpacity: 1,
                weight: 1,
                radius: 9,
                renderer: rulerRenderer
            },
            middle: {
                color: '#0da5d5',
                opacity: 1,
                fillColor: '#0da5d5',
                fillOpacity: 1,
                weight: 1,
                radius: 5,
                renderer: rulerRenderer
            },
            front: {
                color: '#fff',
                opacity: 1,
                fillColor: '#0da5d5',
                fillOpacity: 1,
                weight: 4,
                radius: 2,
                renderer: rulerRenderer
            }
        }
    }
});


================================================
FILE: src/DGRuler/src/LayeredMarker.js
================================================
DG.Ruler.LayeredMarker = DG.Marker.extend({
    options: {
        draggable: false,
        keyboard: false,
        riseOnHover: true,
        pane: 'rulerMarkerPane',
        textDirection: 'auto', // 'auto' | 'ltr' | 'rtl'
        iconHTML: [
            '<img class="dg-ruler__label-spacer" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" width="26" height="26" />',
            '<div class="dg-ruler__label-container">',
            '    <div class="dg-ruler__point"></div>',
            '    <span class="dg-ruler__label-distance">0 км</span>',
            '    <span class="dg-ruler__label-remove-link"></span>',
            '    <div class="dg-ruler__remove-link-overlay"></div>',
            '</div>'
        ].join('\n')
    },

    statics: {
        domClass : 'dg-ruler__label'
    },

    addTo : function(map, layers) {
        Object.keys(this._layers).forEach(function(name) {
            layers[name].addLayer(this._layers[name]);
        }, this);

        this._viewport = layers;
        return DG.Marker.prototype.addTo.call(this.on('move', this._onMove), map);
    },

    onRemove : function(map) {
        Object.keys(this._layers).forEach(function(name) {
            this._viewport[name].removeLayer(this._layers[name]);
        }, this);
        this.off('move', this._onMove);
        this._viewport = null;
        this._style = null;
        return DG.Marker.prototype.onRemove.call(this, map);
    },

    setText : function(text) {
        if (this._iconCollapsed) {
            this.expand();
        }
        this._iconNodes.label.innerHTML = text;
        this._iconNodes.label.setAttribute('dir', this.options.textDirection);
        return this;
    },

    setPointStyle : function(style) {
        if (this._style !== style) {
            Object.keys(this._style = style).forEach(function(name) {
                this._layers[name].setStyle(style[name]);
            }, this);
        }
        return this;
    },

    expand : function() {
        this._iconCollapsed = false;
        this._iconNodes.container.style.display = 'block';
        this._iconNodes.spacer.style.display = 'none';
        return this;
    },

    collapse : function() {
        this._iconCollapsed = true;
        this._iconNodes.container.style.display = 'none';
        this._iconNodes.spacer.style.display = 'block';
        return this;
    },

    querySelector : function(selector) {
        return this._icon.querySelector('.' + DG.Ruler.LayeredMarker.domClass + '-' + selector);
    },

    _onMove : function(event) {
        var latlng = event.latlng;
        Object.keys(this._layers).forEach(function(name) {
            this._layers[name].setLatLng(latlng);
        }, this);
    },

    _initIcon : function() {
        DG.Marker.prototype._initIcon.call(this);
        this._iconCollapsed = true;
        this._icon.style.width = '';
        this._iconNodes = {
            label : this.querySelector('distance'),
            spacer : this.querySelector('spacer'),
            container : this.querySelector('container')
        };
    },

    // don't change icon zIndex
    _setPos: function(pos) {
        L.DomUtil.setPosition(this._icon, pos);

        if (this._shadow) {
            L.DomUtil.setPosition(this._shadow, pos);
        }
    },

    _afterInit : function() {
        this._layers = this.options.layers || null;
        this.options.icon = DG.divIcon({
            className: DG.Ruler.LayeredMarker.domClass,
            iconSize: [26, 26],
            iconAnchor: [13, 13],
            html: this.options.iconHTML
        });
    }

});

DG.Ruler.LayeredMarker.addInitHook('_afterInit');

DG.Ruler.layeredMarker = function(latlng, options) {
    return new DG.Ruler.LayeredMarker(latlng, options);
};


================================================
FILE: src/DGRuler/src/Ruler.js
================================================
DG.Ruler = DG.Layer.extend({

    options: {
        editable: true
    },

    includes: [DG.Locale],

    statics: {
        Dictionary: {}
    },

    initialize: function(latlngs, options) { // (Array, Object)
        DG.Util.setOptions(this, options);

        this._layers = {
            back : null,
            middle : null,
            front : null,
            mouse : null
        };
        this._points = [];

        this._layersContainer = DG.featureGroup();
        Object.keys(this._layers).forEach(function(name) {
            this._layersContainer.addLayer(this._layers[name] = DG.featureGroup());
        }, this);

        this._reset();

        if (DG.Browser.mobile) {
            delete this._lineMouseEvents.mouseover;
            delete this._lineMouseEvents.mouseout;
            delete this._lineMouseEvents.mousemove;
        } else {
            delete this._lineMouseEvents.click;
        }

        if (latlngs && latlngs.length) {
            this.setLatLngs(latlngs);
        }
    },

    onAdd: function(map) { // (Map)
        this._map = map.on('langchange', this._updateDistance, this);

        //  Pane for ruler Markers
        if (!this._map.getPane('rulerMarkerPane')) {
            this._map.createPane('rulerMarkerPane');
        }

        //  Main ruler pane (svg objects and runner)
        if (!this._map.getPane('rulerPane')) {
            this._map.createPane('rulerPane');
        }

        this._layersContainer.addTo(this._map);

        if (this._points.length) {
            this._layers.mouse.fire('layeradd');
            this._updateDistance();
        }

        this._layers.mouse.on(this._lineMouseEvents, this);
    },

    onRemove: function(map) { // (Map)
        map
            .off('langchange', this._updateDistance, this)
            .removeLayer(this._layersContainer);

        this._layers.mouse.off(this._lineMouseEvents, this);
        this._reset();
    },

    getTotalDistance: function() { // () -> Number
        return this._calcDistance();
    },

    spliceLatLngs: function(index) { // (Number, Number, args ...) -> Array
        var oldLength = this._points.length,
            mutationStart = index >= 0 ? Math.min(index, oldLength) : oldLength - index,
            removed = Array.prototype.splice.apply(this._points, arguments).map(function(point) {
                this._layers.mouse.removeLayer(point);
                return point.off().getLatLng();
            }, this),
            length = this._points.length;

        if (length) {
            for (var i = mutationStart; i < length; i++) {
                if (!(this._points[i] instanceof DG.Ruler.LayeredMarker)) {
                    this._points[i] = this._createPoint(this._points[i], this.options.iconStyles.large)
                        .on(this._pointEvents, this)
                        .once('add', this._addCloseHandler, this)
                        .addTo(this._layers.mouse, this._layers);
                }
                if (i && !this._points[i - 1]._legs) {
                    this._addLegs(this._points[i - 1]);
                }
                this._points[i].setPointStyle(this.options.iconStyles[i && i < length - 1 ? 'small' : 'large']);
                this._points[i]._pos = i;
            }
            this._removeLegs(this._points[length - 1]);
            if (oldLength > 0 && oldLength < length) {
                this._points[oldLength - 1].collapse();
            }
            if (this._points[mutationStart]) {
                this._updateLegs(this._points[mutationStart]);
            }
            if (mutationStart > 1) {
                this._points[mutationStart - 1].setPointStyle(this.options.iconStyles.small);
            }
            this._updateDistance();
            this._normalizeRulerPoints();
        }
        if (DG.Browser.touch && this._lineMarkerHelper) {
            this._lineMarkerHelper.collapse();
        }
        this._fireChangeEvent();
        return removed;
    },

    addLatLng: function(latlng) { // (LatLng) -> Ruler
        var lastPoint = this._points[this._points.length - 1] || null;
        latlng = DG.latLng(latlng);

        if (lastPoint) {
            latlng = this._normalizeLatLng(latlng, lastPoint.getLatLng());
        }

        this.spliceLatLngs(this._points.length, 0, latlng);
        return this;
    },

    getLatLngs: function() { // () -> Array
        return this._points.map(function(point) {
            return point.getLatLng();
        });
    },

    setLatLngs: function(latlngs) { // (Array) -> Ruler
        var args = latlngs.slice();
        args.unshift(0, this._points.length);
        this.spliceLatLngs.apply(this, args);
        return this;
    },

    _reset: function() { // ()
        DG.extend(this, {
            _lineMarkerHelper: null,
            _morphingNow: false
        });
    },

    _lineMouseEvents: {
        click: function(event) {
            var target = event.layer;
            if (target instanceof DG.Marker && target._pos !== this._points.length - 1) {
                if (this._lineMarkerHelper) {
                    this._lineMarkerHelper.collapse();
                }
                target.setText(this._getFormatedDistance(target));
                this._lineMarkerHelper = target;
            } else if (target instanceof DG.Path && this.options.editable) {
                var latlng = event.latlng,
                    insertPos = target._point._pos + 1;
                this.spliceLatLngs(insertPos, 0, latlng);
            }
        },
        mouseover: function(event) { // (MouseEvent)
            var target = event.layer;

            target._hovered = true;
            if (this._morphingNow) {
                return;
            }
            if (target instanceof DG.Marker && target._pos !== this._points.length - 1) {
                target.setText(this._getFormatedDistance(target));
            } else if (target instanceof DG.Path && !this._lineMarkerHelper) {
                var point = target._point;

                this._lineMarkerHelper = this._addRunningLabel(
                    this._nearestPoint(point._legs.middle, event.latlng),
                    point
                );
            }
        },
        mouseout: function(event) { // (MouseEvent)
            var target = event.layer,
                originalEv = event.originalEvent;

            target._hovered = false;
            if (this._morphingNow || target._pos === this._points.length - 1) {
                return;
            }
            if (target instanceof DG.Marker) {
                // collapse only when we move out from label container (if browser support relatedTarget)
                if (!originalEv.relatedTarget ||
                    (originalEv.relatedTarget !== target.querySelector('container') &&
                    originalEv.relatedTarget.parentNode !== target.querySelector('container'))) {
                    target.collapse();
                }
            } else {
                this._removeRunningLabel();
            }
        },
        mousemove: function(event) { // (MouseEvent)
            if (this._morphingNow || !this._lineMarkerHelper) {
                return;
            }

            var point = event.layer._point,
                latlng = this._nearestPoint(point._legs.middle, event.latlng);

            this._lineMarkerHelper
                .setLatLng(latlng)
                .setText(this._getFormatedDistance(point, point.getLatLng().distanceTo(latlng)));
        },
        layeradd: function() { // ()
            Object.keys(this._layers).forEach(function(name) {
                this._layers[name].bringToFront();
            }, this);
        }
    },

    _fireChangeEvent: function() {
        this.fire('changed', {latlngs : this.getLatLngs()});
    },

    _addRunningLabel: function(latlng, previousPoint) { // (LatLng, Ruler.LayeredMarker)
        var point = this._createPoint(latlng).addTo(this._layers.mouse, this._layers);
        var pane = this._map.getPane('rulerPane');
        pane.insertBefore(point._icon, pane.lastElementChild);
        return point.setText(this._getFormatedDistance(previousPoint, previousPoint.getLatLng().distanceTo(latlng)));
    },

    _removeRunningLabel: function() { // ()
        if (this._lineMarkerHelper) {
            this._layers.mouse.removeLayer(this._lineMarkerHelper);
            this._lineMarkerHelper = null;
        }
    },

    _insertPointInLine: function(event) { // (MouseEvent)
        var latlng = this._lineMarkerHelper.getLatLng(),
            insertPos = event.target._point._pos + 1,
            point;

        if (L.Browser.ie) {
            var path = event.originalEvent.target || event.originalEvent.srcElement,
                parent = path.parentNode;
            parent.appendChild(path); // IE click event leaking problem solution: we reappend mousedown event target element
        }

        L.DomEvent.stopPropagation(event.originalEvent);

        this.spliceLatLngs(insertPos, 0, latlng);
        point = this._points[insertPos];
        point.setText(this._getFormatedDistance(point));

        setTimeout(function() {
            if (document.createEvent) {
                var e = document.createEvent('MouseEvents');
                e.initMouseEvent('mouseup', false, false, document.defaultView, 1, 0, 0, 0, 0, false, false, false, false, 1, point._icon);
                document.dispatchEvent(e);

                e = document.createEvent('MouseEvents');
                e.initMouseEvent('mousedown', false, false, document.defaultView, 1, 0, 0, 0, 0, false, false, false, false, 1, point._icon);
                point._icon.dispatchEvent(e);
            } else {
                point._icon.fireEvent('onMouseUp', DG.extend(document.createEventObject(), {
                    button: 1,
                    bubbles: false,
                    cancelable: false
                }));
                point._icon.fireEvent('onMouseDown', DG.extend(document.createEventObject(), {
                    button: 1,
                    bubbles: false,
                    cancelable: false
                }));
            }
        }, 0);

        this._removeRunningLabel();

        this._updateLegs(point);
    },

    // Find the point on given polyline which is closest to given latlng
    _nearestPoint: function(polyline, latlng) { // (Polyline, LatLng) -> LatLng
        var self = this;

        // Convert everything to pixel coordinates
        var point = this._project(latlng);
        var linePoints = polyline.getLatLngs().map(function(latlng) {
            return self._project(latlng);
        });

        // First look for closest polyline segment
        var minDistance;
        var closestSegmentIndex;
        for (var i = 0; i < linePoints.length - 1; i++) {
            var distance = DG.LineUtil.pointToSegmentDistance(
                point,
                linePoints[i],
                linePoints[i + 1]
            );

            if (minDistance === undefined || distance < minDistance) {
                minDistance = distance;
                closestSegmentIndex = i;
            }
        }

        // Then look for closest point on that segment
        var closestPoint = DG.LineUtil.closestPointOnSegment(
            point,
            linePoints[closestSegmentIndex],
            linePoints[closestSegmentIndex + 1]
        );

        // Convert back to LatLng
        return this._unproject(closestPoint);
    },

    _addCloseHandler: function(event) { // (Event)
        event.target
            .on('click', this._deletePoint, this)
            .querySelector('remove-link').style.display = 'inline-block';
    },

    _createPoint: function(latlng, style) { // (LatLng, Object) -> Ruler.LayeredMarker
        var pointStyle = style ? style : this.options.iconStyles.large,
            layers = {};
        Object.keys(pointStyle).forEach(function(layer) {
            layers[layer] = DG.circleMarker(latlng, pointStyle[layer]);
        });

        return DG.Ruler.layeredMarker(latlng, {
            layers : layers,
            draggable : this.options.editable,
            textDirection: this._map.getLang() !== 'ar' ? 'auto' : 'rtl'
        });
    },

    // Moves curr LatLng to correct world if necessary so that ruler section
    // between curr and base can be plotted correctly. Returns a new LatLng
    // object.
    _normalizeLatLng: function(curr, base) { // (LatLng, LatLng) -> LatLng
        var diff = (curr.lng < base.lng) ? 360 : -360;

        var newLng = curr.lng;
        while (Math.abs(newLng - base.lng) > 180) {
            newLng += diff;
        }

        return DG.latLng(curr.lat, newLng);
    },

    // Rearranges ruler points between worlds based on point param so that all
    // ruler sections can be plotted correctly.
    _normalizeRulerPoints: function(point) { // (Ruler.LayeredMarker)
        point = point || this._points[0];

        var self = this;
        var position = point._pos;
        var changedPoints = [];
        var i, currPoint, prevPoint, latlng, normalized;

        // Check points to the right
        for (i = position + 1; i < this._points.length; i++) {
            currPoint = this._points[i];
            prevPoint = this._points[i - 1];

            latlng = currPoint.getLatLng();
            normalized = this._normalizeLatLng(latlng, prevPoint.getLatLng());

            if (!normalized.equals(latlng)) {
                currPoint.setLatLng(normalized);
                changedPoints.push(i);
            }
        }

        // Check points to the left
        for (i = position - 1; i >= 0; i--) {
            currPoint = this._points[i];
            prevPoint = this._points[i + 1];

            latlng = currPoint.getLatLng();
            normalized = this._normalizeLatLng(latlng, prevPoint.getLatLng());

            if (!normalized.equals(latlng)) {
                currPoint.setLatLng(normalized);
                changedPoints.push(i);
            }
        }

        // Update legs of all points that changed position
        changedPoints.sort().reduce(function(previous, current) {
            var skipPrevious = previous && previous === current - 1;

            self._updateLegs(self._points[current], skipPrevious);

            return current;
        }, null);
    },

    _pointEvents: {
        drag: function(event) { // (Event)
            var point = event.target;

            this._normalizeRulerPoints(point);

            if (!DG.Browser.touch && point !== this._points[this._points.length - 1]) {
                point.setText(this._getFormatedDistance(point));
            }

            this._updateLegs(point);
            this._updateDistance();
        },
        dragend: function(event) { // (Event)
            var point = event.target;
            this._morphingNow = false;
            if (!point._hovered && point !== this._points[this._points.length - 1]) {
                point.collapse();
            }
            this._fireChangeEvent();
        },
        dragstart: function() { // ()
            if (DG.Browser.touch && this._lineMarkerHelper) {
                this._lineMarkerHelper.collapse();
            }
            this._morphingNow = true;
        }
    },

    _deletePoint: function(event) { // (MouseEvent)
        var originalEvent = event.originalEvent,
            target = originalEvent.target  || originalEvent.srcElement;

        if (target.className !== 'dg-ruler__label-remove-link' &&
            target.className !== 'dg-ruler__remove-link-overlay') {
            return;
        }
        DG.DomEvent.stop(event.originalEvent);
        this.spliceLatLngs(event.target._pos, 1);
    },

    _degToRad: function(deg) {
        return (Math.PI / 180) * deg;
    },

    _radToDeg: function(rad) {
        return (180 / Math.PI) * rad;
    },

    // Map-independent project method
    _project: function(latlng) {
        if (this._map) {
            return this._map.project(latlng);
        }

        return DG.CRS.EPSG3857.latLngToPoint(latlng, 1);
    },

    // Map-independent unproject method
    _unproject: function(point) {
        if (this._map) {
            return this._map.unproject(point);
        }

        return DG.CRS.EPSG3857.pointToLatLng(point, 1);
    },

    // Calculates the size of angle point1-point-point2
    _calcAngle: function(point, point1, point2) { // (LatLng, LatLng, LatLng) -> Number
        point1 = this._normalizeLatLng(point1, point);
        point2 = this._normalizeLatLng(point2, point);

        point = this._project(point);
        point1 = this._project(point1);
        point2 = this._project(point2);

        var x1 = point1.x - point.x;
        var x2 = point2.x - point.x;
        var y1 = point1.y - point.y;
        var y2 = point2.y - point.y;

        var dotProduct = x1 * x2 + y1 * y2;
        var mag1 = Math.sqrt(x1 * x1 + y1 * y1);
        var mag2 = Math.sqrt(x2 * x2 + y2 * y2);

        return Math.acos(dotProduct / (mag1 * mag2));
    },

    // Calculates the midpoint on the great circle between two LatLngs
    _calcMidPoint: function(latlng1, latlng2) { // (LatLng, LatLng) -> LatLng
        var lon1 = this._degToRad(latlng1.lng);
        var lat1 = this._degToRad(latlng1.lat);

        var lon2 = this._degToRad(latlng2.lng);
        var lat2 = this._degToRad(latlng2.lat);

        // Based on formulae from
        // http://williams.best.vwh.net/avform.htm#Intermediate
        var d = Math.acos(Math.sin(lat1) * Math.sin(lat2) +
            Math.cos(lat1) * Math.cos(lat2) * Math.cos(lon1 - lon2));

        // Split the arc in half
        var f = 0.5;

        var A = Math.sin((1 - f) * d) / Math.sin(d);
        var B = Math.sin(f * d) / Math.sin(d);

        var x = A * Math.cos(lat1) * Math.cos(lon1) +
            B * Math.cos(lat2) * Math.cos(lon2);

        var y = A * Math.cos(lat1) * Math.sin(lon1) +
            B * Math.cos(lat2) * Math.sin(lon2);

        var z = A * Math.sin(lat1) + B * Math.sin(lat2);

        var lat = Math.atan2(z, Math.sqrt(x * x + y * y));
        var lon = Math.atan2(y, x);

        return DG.latLng(this._radToDeg(lat), this._radToDeg(lon));
    },

    // Adaptive sampling algorithm based on
    // http://ariel.chronotext.org/dd/defigueiredo93adaptive.pdf
    _adaptiveSample: function(left, right, depth, middle) { // (LatLng, LatLng, Number[, LatLng]) -> LatLng[]
        if (depth > 9) {
            // Max recursion depth reached
            return [];
        }

        middle = middle || this._calcMidPoint(left, right);

        var leftMiddle = this._calcMidPoint(left, middle);
        var rightMiddle = this._calcMidPoint(middle, right);

        var angle1 = this._calcAngle(leftMiddle, middle, left);
        var angle2 = this._calcAngle(middle, left, right);
        var angle3 = this._calcAngle(rightMiddle, middle, right);

        // left --- leftMiddle --- middle --- rightMiddle --- right
        //            angle1       angle2       angle3

        var minAngle = 3.1;
        if (angle1 > minAngle && angle2 > minAngle && angle3 > minAngle) {
            // This section is straight enough, no intermediate points needed.
            return [];
        } else {
            // Angles are too small. Recursively sample halves of this section.
            var result = [];
            result = result.concat(this._adaptiveSample(left, middle, depth + 1, leftMiddle));
            result.push(middle);
            result = result.concat(this._adaptiveSample(middle, right, depth + 1, rightMiddle));

            return result;
        }
    },

    // Calculates the great circle arc between two LatLngs.
    _calcGreatCircle: function(latlng1, latlng2) { // (LatLng, LatLng) -> LatLng[]
        latlng2 = this._normalizeLatLng(latlng2, latlng1);

        // Special case: points are close to each other (within 1 degree)
        if (latlng1.equals(latlng2, 1)) {
            return [latlng1, latlng2];
        }

        // Special case: the great circle crosses a pole
        if (Math.abs(latlng2.lng - latlng1.lng) == 180) {
            // North or south pole?
            var latitude = (latlng1.lat + latlng2.lat > 0) ? 90 : -90;

            return [
                latlng1,
                DG.latLng(latitude, latlng1.lng),
                DG.latLng(latitude, latlng2.lng),
                latlng2
            ];
        }

        var result = [];

        result.push(latlng1);
        result = result.concat(this._adaptiveSample(latlng1, latlng2, 0));
        result.push(latlng2);

        // Make sure the arc doesn't jump between worlds
        for (var i = 1; i < result.length; i++) {
            result[i] = this._normalizeLatLng(result[i], result[i - 1]);
        }

        return result;
    },

    _addLegs: function(point) {
        var pathStyles = this.options.pathStyles;

        var greatCirclePoints = this._calcGreatCircle(
            point.getLatLng(),
            this._points[point._pos + 1].getLatLng()
        );

        point._legs = {};
        Object.keys(pathStyles).forEach(function(layer) {
            point._legs[layer] = DG.polyline(greatCirclePoints, pathStyles[layer]).addTo(this._layers[layer]);
        }, this);

        point._legs.mouse._point = point.once('remove', this._clearRemovingPointLegs, this);

        if (this.options.editable && !DG.Browser.mobile) {
            point._legs.mouse.on('mousedown', this._insertPointInLine, this);
        }

        if (this._map) {
            this._layers.mouse.addLayer(point._legs.mouse);
        }
    },

    _clearRemovingPointLegs: function(event) { // (Event)
        this._removeLegs(event.target);
    },

    _removeLegs: function(point) { // (Ruler.LayeredMarker)
        if (point._legs) {
            Object.keys(point._legs).forEach(function(layer) {
                this._layers[layer].removeLayer(point._legs[layer]);
            }, this);
            point._legs = null;
        }
    },

    _updateLegs: function(point, skipPrevious) { // (Ruler.LayeredMarker, Boolean)
        var latlng = point.getLatLng(),
            previousPoint = this._points[point._pos - 1],
            nextPoint = this._points[point._pos + 1],
            self = this,
            newPoints;

        if (previousPoint && !skipPrevious) {
            newPoints = self._calcGreatCircle(previousPoint.getLatLng(), latlng);

            Object.keys(previousPoint._legs).forEach(function(layer) {
                previousPoint._legs[layer].setLatLngs(newPoints);
            });
        }

        if (nextPoint) {
            newPoints = self._calcGreatCircle(latlng, nextPoint.getLatLng());

            Object.keys(point._legs).forEach(function(layer) {
                point._legs[layer].setLatLngs(newPoints);
            });
        }
    },

    _calcDistance: function(finishPoint, tail) { // (Ruler.LayeredMarker, Number) -> Number
        var distance = tail ? tail : 0,
            calcTo = finishPoint ? finishPoint._pos : this._points.length - 1;

        for (var i = 0; i < calcTo; i++) {
            distance += this._points[i].getLatLng().distanceTo(this._points[i + 1].getLatLng());
        }

        return distance;
    },

    _getFormatedDistance: function() { // () -> String
        var distance = this._calcDistance.apply(this, arguments),
            units = 'm';

        if (distance > 1000) {
            distance /= 1000;
            units = 'km';
            if (distance > 1000) {
                distance = distance.toFixed();
                distance = distance.slice(0, -3) + ' ' + distance.slice(-3);
            } else {
                distance = distance.toFixed(2).split('.').join(this.t('delimiter'));
            }
        } else {
            distance = Math.round(distance);
        }

        return [distance || 0, ' ', this.t(units)].join('');
    },

    _updateDistance: function() { // ()
        if (this._map && this._points.length) {
            this._points[this._points.length - 1].setText(this._getFormatedDistance());
        }
    }
});

DG.ruler = function(latlngs, options) { // (Array, Object)
    return new DG.Ruler(latlngs, options);
};


================================================
FILE: src/DGRuler/test/RulerSpec.js
================================================
describe('DG.Ruler', function () {

    var map,
        ruler,
        mRuler = [[54.98876904122557, 82.901930809021], [54.988842907519285, 82.89030075073241]],
        kmRuler = [[54.9798794714156, 82.89888381958008], [54.9788204717771, 82.89695262908936],
                   [54.98273616833678, 82.88879871368408], [54.98194813431667, 82.87236213684082]],
        originalLatLngs = [
            [1, 2],
            [3, 4],
            [5, 6]
        ];

    after(function() {
        mRuler = kmRuler = originalLatLngs = null;
    });

    beforeEach(function () {
        map = new DG.Map(document.createElement('div'), {
            center: new DG.LatLng(51.7302800, 36.1938900),
            zoom: 17,
            key: window.__karma__.config.secretKey,
        });
        ruler = DG.ruler();
        map.addLayer(ruler);
    });

    afterEach(function () {
        map && map.remove();
        ruler = map = null;
    });

    describe("#setLatLngs", function () {
        it("doesn't overwrite the given latlng array", function () {
            var sourceLatLngs = originalLatLngs.slice();

            ruler.setLatLngs(originalLatLngs);
            expect(sourceLatLngs).to.eql(originalLatLngs);
            expect(ruler._points).to.not.eql(sourceLatLngs);
        });
        it("chains ruler instance", function () {
            expect(ruler.setLatLngs(originalLatLngs)).to.be.a(DG.Ruler);
        });
    });

    describe("#getLatLngs", function () {
        it("should return empty array", function () {
            expect(ruler.getLatLngs()).to.eql([]);
        });
        it("should return latLngs array", function () {
            ruler.setLatLngs(originalLatLngs);
            expect(ruler.getLatLngs()).to.eql([DG.latLng([1, 2]), DG.latLng([3, 4]), DG.latLng([5, 6])]);
        });
    });

    describe("#addLatLng", function () {
        it("doesn't overwrite the given latlng", function () {
            var a = [5, 6],
                b = [5, 6];

            ruler.setLatLngs(originalLatLngs);
            ruler.addLatLng(a);
            expect(a).to.eql(b);
        });
        it("adds the given latlng to ruler", function () {
            ruler.setLatLngs(originalLatLngs);
            ruler.addLatLng([7, 8]);
            expect(ruler.getLatLngs()).to.eql([DG.latLng([1, 2]), DG.latLng([3, 4]), DG.latLng([5, 6]), DG.latLng([7, 8])]);
        });
        it("chains ruler instance", function () {
            expect(ruler.addLatLng(originalLatLngs[0])).to.be.a(DG.Ruler);
        });
    });

    describe("#spliceLatLngs", function () {
        it("returns removed latLngs", function () {
            ruler.setLatLngs(originalLatLngs);
            expect(ruler.spliceLatLngs(1, 1, [7, 8])).to.eql([DG.latLng([3, 4])]);
        });
        it("inserts the latLngs", function () {
            ruler.setLatLngs(originalLatLngs);
            ruler.spliceLatLngs(1, 1, [7, 8]);
            expect(ruler.getLatLngs()).to.eql([DG.latLng([1, 2]), DG.latLng([7, 8]), DG.latLng([5, 6])]);
        });
    });

    describe('#getTotalDistance', function () {
        it('meters', function () {
            mRuler.forEach(function (ll) {
                ruler.addLatLng(ll);
            });
            // it makes no sense to check with higher accuracy than 1 cm.
            var roundedDistance = Math.round(ruler.getTotalDistance() * 100) / 100;
            expect(roundedDistance).to.eql(742);
            expect(ruler._getFormatedDistance()).to.eql('742 м');
        });
        it('km', function () {
            kmRuler.forEach(function (ll) {
                ruler.addLatLng(ll);
            });
            // it makes no sense to check with higher accuracy than 1 cm.
            var roundedDistance = Math.round(ruler.getTotalDistance() * 100) / 100;
            expect(roundedDistance).to.eql(1901.31);
            expect(ruler._getFormatedDistance()).to.eql('1,90 км');
        });
    });

});


================================================
FILE: src/DGRulerControl/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>
    <title>DGRulerControl demo</title>
    <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>
    <style type="text/css">
        html,body { height: 100%; margin: 0; padding: 0; }
        #map { width: 100%; height: 100%; }
    </style>
</head>
<body>
    <div id="map"></div>
    <script type="text/javascript">
        DG.then(function () {
            map = new DG.Map('map', {
                'center': new DG.LatLng(51.7302800, 36.1938900),
                'zoom': 17,
                key: DG.config.key || 'Your API access key'
            });

            map.addControl(DG.control.ruler());
        });
    </script>
</body>
</html>


================================================
FILE: src/DGRulerControl/lang/ar.js
================================================
DG.Control.Ruler.Dictionary.ar = {
    button_title: 'مسطرة'
};


================================================
FILE: src/DGRulerControl/lang/cs.js
================================================
DG.Control.Ruler.Dictionary.cs = {
    button_title: 'Pravítko'
};


================================================
FILE: src/DGRulerControl/lang/en.js
================================================
DG.Control.Ruler.Dictionary.en = {
    button_title : 'Ruler'
};


================================================
FILE: src/DGRulerControl/lang/es.js
================================================
DG.Control.Ruler.Dictionary.es = {
    button_title : 'Regla'
};


================================================
FILE: src/DGRulerControl/lang/it.js
================================================
DG.Control.Ruler.Dictionary.it = {
    button_title : 'Righello'
};


================================================
FILE: src/DGRulerControl/lang/ru.js
================================================
DG.Control.Ruler.Dictionary.ru = {
    button_title: 'Линейка'
};


================================================
FILE: src/DGRulerControl/skin/basic/less/dg-control-round.less
================================================
.dg-control-round__icon_name_ruler {
    &:after {
        .notRepeatableBgWithSizes('DGRoundControl__rulerIcon');
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        margin: auto;
        content: '';
    }

    .no-touch &:hover:after,
    &:active:after {
        .notRepeatableBg('DGRoundControl__rulerIconHover');
    }

    .dg-control-round__icon_state_active&:after,
    .no-touch .dg-control-round__icon_state_active&:hover:after,
    .dg-control-round__icon_state_active&:active:after {
        .notRepeatableBg('DGRoundControl__rulerIconEnabled');
    }
}


================================================
FILE: src/DGRulerControl/src/Control.Ruler.js
================================================
DG.Control.Ruler = DG.RoundControl.extend({

    options: {
        position: 'topright',
        iconClass: 'ruler'
    },

    statics: {
        Dictionary: {}
    },

    initialize: function(options) {
        DG.setOptions(this, options);
        DG.extend(this, {
            _active: false,
            _drawingHelper: null,
            _geoclickerNeedRestore: false
        }).on(this._controlEvents, this);
    },

    _controlEvents: {
        add: function() {
            this._drawingHelper = DG.ruler([]);
        },
        click: function() {
            this._active = !this._active;

            if (this._active) {
                this.setState('active');
                this._startDrawing();
            } else {
                this.setState('');
                this._finishDrawing();
            }
        },
        remove: function() {
            this.off(this._controlEvents, this);
            if (this._active) {
                this._map.removeLayer(this._drawingHelper);
                this._active = false;
            }
            this._drawingHelper = null;
        }
    },

    _startDrawing: function() { // ()
        this._map
            .addLayer(this._drawingHelper)
            .on('click', this._handleMapClick, this);

        this._map.fire('rulerstart');
    },

    _finishDrawing: function() { // ()
        this._map
            .off('click', this._handleMapClick, this)
            .removeLayer(this._drawingHelper);

        this._drawingHelper.setLatLngs([]);

        this._map.fire('rulerend');
    },

    _handleMapClick: function(event) { // (MouseEvents)
        this._drawingHelper.addLatLng(event.latlng);
    },

    _renderTranslation: function() { // ()
        this._link.title = this.t('button_title');
    }
});

DG.control.ruler = function(options) {
    return new DG.Control.Ruler(options);
};

DG.Map.mergeOptions({
    rulerControl: false
});

DG.Map.addInitHook(function() {
    if (this.options.rulerControl) {
        this.rulerControl = DG.control.ruler(this.options.rulerControl);
        this.addControl(this.rulerControl);
    }
});


================================================
FILE: src/DGRulerControl/test/DGRulerControlSpec.js
================================================
describe('DG.Control.Ruler', function() {
    var map, mapContainer, control, classControl, containerControl, ruler;

    before(function() {
        classControl = 'dg-control-round__icon_name_ruler';

        mapContainer = document.createElement('div');
        document.body.appendChild(mapContainer);

        map = new DG.Map(mapContainer, {
            center: [55.017493, 82.819576],
            zoom: 15,
            key: window.__karma__.config.secretKey,
        });

        control = DG.control.ruler();
    });

    after(function() {
        mapContainer.parentElement.removeChild(mapContainer);
        map.remove();
        map = mapContainer = control = classControl = containerControl = ruler = null;
    });

    describe('#addTo', function() {
        before(function() {
            control.addTo(map);
        });

        it('should map has ruler contrainer', function() {
            containerControl = document.body.getElementsByClassName(classControl);
            expect(containerControl.length).to.be(1);
            containerControl = containerControl[0];
            ruler = control._drawingHelper;
        });
    });

    describe('drawing', function() {
        it('should container has active class', function() {
            happen.click(containerControl);
            expect(containerControl.className).to.contain('active');
        });

        it('should change ruler after click on map', function() {
            var latlng = DG.latLng(54.980206086231, 82.898068362003),
                rulerLatLngs;

            map.fire('click', {latlng: latlng});
            rulerLatLngs = ruler.getLatLngs();

            expect(rulerLatLngs.length).to.be(1);
            expect(rulerLatLngs[0]).to.nearLatLng(latlng);
        });

        it('should change ruler after second click on map', function() {
            var latlng = DG.latLng(54.980206086231, 82.891068362003),
                rulerLatLngs;

            map.fire('click', {latlng: latlng});
            rulerLatLngs = ruler.getLatLngs();

            expect(rulerLatLngs.length).to.be(2);
            expect(rulerLatLngs[1]).to.nearLatLng(latlng);
        });

        it('should hasn\'t ruler layer on map', function() {
            happen.click(containerControl);
            expect(map.hasLayer(ruler._layersContainer)).not.be.ok();
        });
    });

    describe('#remove', function() {
        before(function() {
            happen.click(containerControl);
            map.fire('click', {latlng: DG.latLng(54.980206086231, 82.891068362003)});

            control.remove();
        });

        it('should hasn\'t ruler layer on map', function() {
            expect(map.hasLayer(ruler._layersContainer)).not.be.ok();
        });

        it('should map hasn\'t ruler contrainer', function() {
            expect(document.body.getElementsByClassName(classControl).length).to.be(0);
        });
    });
});


================================================
FILE: src/DGTraffic/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>
    <title>DGTraffic demo</title>
    <script src="http://maps.api.2gis.dev/2.0/loader.js"></script>
    <style type="text/css">
        html,body { height: 100%; margin: 0; padding: 0; }
        #map { width: 100%; height: 100%; }
    </style>
</head>
<body>
    <div id="map"></div>
    <script type="text/javascript">
        var map;

        DG.then(function () {
            map = new DG.Map('map', {
                "center": new DG.LatLng(54.95070983406191, 83.0569839477539),
                "zoom": 11,
                "geoclicker": false,
                key: DG.config.key || 'Your API access key'
            });

            var traffic = new DG.Traffic();
            map.addLayer(traffic);

        });
    </script>
</body>
</html>


================================================
FILE: src/DGTraffic/lang/ar.js
================================================
DG.Traffic.Dictionary.ar = {
    speed_unit_km_h: 'كم/ساعة'
};


================================================
FILE: src/DGTraffic/lang/cs.js
================================================
DG.Traffic.Dictionary.cs = {
    speed_unit_km_h: 'km/h'
};


================================================
FILE: src/DGTraffic/lang/en.js
================================================
DG.Traffic.Dictionary.en = {
    speed_unit_km_h: 'km/h'
};


================================================
FILE: src/DGTraffic/lang/es.js
================================================
DG.Traffic.Dictionary.es = {
    speed_unit_km_h: 'km/h'
};


================================================
FILE: src/DGTraffic/lang/it.js
================================================
DG.Traffic.Dictionary.it = {
    speed_unit_km_h: 'km/h'
};


================================================
FILE: src/DGTraffic/lang/ru.js
================================================
DG.Traffic.Dictionary.ru = {
    speed_unit_km_h: 'км/ч'
};


================================================
FILE: src/DGTraffic/src/DGTraffic.js
================================================
DG.Traffic = DG.TileLayer.extend({
    options: {
        period: 0,
        disableLabel: false,
        updateWhenIdle: false // display new traffic tiles on move for mobile
    },

    statics: {
        Dictionary: {}
    },

    initialize: function(options) {
        this._tileUrl = DG.config.protocol + (DG.Browser.retina ? DG.config.retinaTrafficTileServer : DG.config.trafficTileServer);
        this._metaUrl = DG.config.protocol + (DG.Browser.retina ? DG.config.retinaTrafficMetaServer : DG.config.trafficMetaServer);
        this._timeUrl = DG.config.protocol + DG.config.trafficTimestampServer;
        this._updateInterval = DG.config.trafficLayerUpdateInterval;

        this._layersOptions = {
            errorTileUrl: 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7',
            subdomains: '012345679',
            maxNativeZoom: 18,
            detectRetina: DG.config.detectRetina,
            minZoom: DG.config.trafficLayerMinZoom
        };

        options = DG.setOptions(this, DG.extend(options || {}, this._layersOptions));
        this._metaLayer = DG.Meta.layer(null, {
            detectRetina: options.detectRetina,
            maxNativeZoom: options.maxNativeZoom,
            dataFilter: DG.bind(this._processData, this),
            minZoom: options.minZoom
        });
        this._isDg = true;
        this._isOnRequest = false; // timestampString request flag
        this._onTimer = DG.bind(this._onTimer, this);
        DG.TileLayer.prototype.initialize.call(this, this._tileUrl, options);
    },

    // #setTime(day [0-6], time[0-23]) ????

    onAdd: function(map) {
        this._initContainer();
        this._levels = {};
        this._tiles = {};

        if (this.options.period) {
            this.options.timestampString = '';
            this._onAddSetParams(map);
        } else {
            var self = this;
            this._isOnRequest = true;
            this._getTimestampString()
                .then(
                    function(response) {
                        self.options.timestampString = '?' + response;
                    },
                    function() {
                        self.options.timestampString = '?' + (new Date()).getTime();
                    })
                .then(
                    function() {
                        self._isOnRequest = false;
                        if (self._map) { // if traffic layer has not been removed from map before server response and timestampString variable is assigned
                            self._onAddSetParams(map);
                        }
                    }
                );
        }
    },

    onRemove: function(map) {
        if (!this._isOnRequest) {
            clearInterval(this._updateTimer);

            map
                .removeLayer(this._metaLayer)
                .off('projectchange projectleave', this._onMapProjectChange, this);

            if (!this.options.disableLabel) {
                this._metaLayer.off(this._layerEventsListeners, this);
                this._map.removeLayer(this._labelHelper);
                this._labelHelper = null;
                this._map.off('langchange', this._updateLang, this);
            }

            DG.TileLayer.prototype.onRemove.call(this, map);
        } else {
            L.DomUtil.remove(this._container);
            map._removeZoomLimit(this);
            this._container = null;
        }
    },

    update: function() {
        var self = this;
        this._getTimestampString().then(
            function(response) {
                self.options.timestampString = '?' + response;
            },
            function() {
                self.options.timestampString = '?' + (new Date()).getTime();
            }).then(
            function() {
                self.fire('update', {timestamp: self.options.timestampString});
                self._layerEventsListeners.mouseout.call(self);
                self._metaLayer.getOrigin().setURL(self._prepareMetaURL(), self);
                self.redraw();
            }
        );
    },

    getSubdomain: function() {
        return this._layersOptions.subdomains[
            Math.floor(Math.random() * this._layersOptions.subdomains.length)
        ];
    },

    _updateLang: function() {
        var lang = this._map.getLang();
        if (lang === 'ar') {
            this._labelHelper.options.textDirection = 'rtl';
        } else {
            this._labelHelper.options.textDirection = 'auto';
        }
    },

    _getTimestampString: function() {
        return DG.ajax(
            DG.Util.template(
                this._timeUrl,
                DG.extend({
                    s : this.getSubdomain(),
                    projectCode: this._map.projectDetector.getProject().code
                }, this.options || {})),
            {type: 'get'}
        );
    },

    _onTimer: function() {
        if (this.options.period === 0) {
            this.update();
        }
    },

    _processData: function(trafficData, coord) {
        var tileOriginPoint = coord.scaleBy(this.getTileSize());
        var polygonLngLatToPoints = DG.bind(this._polygonLngLatToPoints, this, tileOriginPoint);
        var hints = {};

        if (!DG.Util.isArray(trafficData)) {    // TODO remove
            return [];
        }

        trafficData[1].forEach(function(item) {
            this[item.graph_id] = item.speed_text;
        }, hints);

        return trafficData[0]
            .map(function(item) {
                return {
                    id: item.graph_id,
                    speed: hints[item.graph_id],
                    geometry: DG.Wkt.toGeoJSON(item.geometry[0].object[0])
                };
            })
            .filter(function(item) {
                return item.geometry.type == 'Polygon' ||
                    item.geometry.type == 'MultiPolygon';
            })
            .map(function(item) {
                var geoJson = item.geometry;

                if (geoJson.type == 'Polygon') {
                    geoJson.coordinates = polygonLngLatToPoints(geoJson.coordinates);
                } else if (geoJson.type == 'MultiPolygon') {
                    geoJson.coordinates = geoJson.coordinates.map(polygonLngLatToPoints);
                }

                return item;
            });
    },

    _polygonLngLatToPoints: function(originPoint, polygon) {
        var map = this._map;

        return polygon.map(function(contour) {
            return contour.map(function(lngLat) {
                return map
                    .project([lngLat[1], lngLat[0]]).round()
                    .subtract(originPoint);
            });
        });
    },

    _prepareMetaURL: function() {
        return DG.Util.template(this._metaUrl, DG.extend({
            x: '{x}',
            y: '{y}',
            z: '{z}',
            s: '{s}'
        }, this.options));
    },

    _updateLayerProject: function() {
        var project = this._map.projectDetector.getProject();
        DG.setOptions(this, project && project.traffic ? {
            projectCode: project.code,
            bounds: project.latLngBounds,
            minZoom: Math.max(project.minZoom, this._layersOptions.minZoom),
            maxZoom: project.maxZoom
        } : {
            maxZoom: project ? project.maxZoom : DG.config.projectLeaveMaxZoom,
            minZoom: 0
        });
        this._metaLayer.getOrigin().setURL(this._prepareMetaURL());
    },

    _onMapProjectChange: function() {
        this._updateLayerProject();
        this.redraw();
    },

    _layerEventsListeners: {
        mouseover: function(e) { // (Object)
            this._setCursor('pointer');
            if (this._labelHelper && e.meta.speed) {
                this._labelHelper
                    .setPosition(e.latlng)
                    .setContent(e.meta.speed + ' ' + this.t('speed_unit_km_h'))
                    .addTo(this._map);
            }
        },
        mouseout: function() {
            this._setCursor('');
            if (this._labelHelper) {
                this._map.removeLayer(this._labelHelper);
            }
        },
        mousemove: function(e) {
            if (this._labelHelper) {
                this._labelHelper.setPosition(e.latlng);
            }
        }
    },

    _setCursor: function(cursor) { // (String)
        this._map.getContainer().style.cursor = cursor;
    },

    _onAddSetParams: function(map) {
        this._updateLayerProject();

        map
            .addLayer(this._metaLayer)
            .on('projectchange projectleave', this._onMapProjectChange, this);

        if (!this.options.disableLabel) {
            this._metaLayer.on(this._layerEventsListeners, this);
            this._labelHelper = DG.label();
            this._map.on('langchange', this._updateLang, this);
        }

        if (this._updateInterval) {
            this._updateTimer = setInterval(this._onTimer, this._updateInterval);
        }

        this._resetView();
        this._update();
    },

    _update: function(center) {
        if (!this._isOnRequest) {
            DG.TileLayer.prototype._update.call(this, center);
        }
    }

});

DG.Traffic.include(DG.Locale);

DG.traffic = function(options) { // (Object)
    return new DG.Traffic(options);
};


================================================
FILE: src/DGTraffic/test/DGTrafficSpec.js
================================================
describe('DG.traffic', function () {
    var map,
        traffic,
        mapContainer,
        xhr,
        requests;

    before(function () {
        mapContainer = document.createElement('div');
        document.body.appendChild(mapContainer);
        map = new DG.Map(mapContainer, {
            center: new DG.LatLng(54.980156831455, 82.897440725094),
            zoom: 17,
            key: window.__karma__.config.secretKey,
        });
        xhr = sinon.useFakeXMLHttpRequest();
        requests = [];

        xhr.onCreate = function (xhr) {
            requests.push(xhr);
        };
    });

    afterEach(function () {
        map.removeLayer(traffic);
    });

    after(function () {
        map.remove();
        document.body.removeChild(mapContainer);
        map = traffic = mapContainer = null;
        xhr.restore();
    });

    it('should present two layer', function (done) {
        traffic = DG.traffic();
        traffic.addTo(map);
        requests[0].respond(200, {'Content-Type': 'application/x-www-form-urlencoded'}, (new Date()).getTime().toString());

        setTimeout(function() {
            var layers = mapContainer.querySelectorAll('.leaflet-layer');
            expect(layers.length).to.eql(2);
            done();
        }, 0);
    });

});


================================================
FILE: src/DGTrafficControl/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>DGTrafficControl demo</title>
    <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>
    <style type="text/css">
        html,body { height: 100%; margin: 0; padding: 0; }
        #map { width: 100%; height: 100%; }
    </style>
</head>
<body>
    <div id="map"></div>
    <script type="text/javascript">
        DG.then(function () {
            map = new DG.Map('map', {
                'center': new DG.LatLng(59.92160287366319, 30.313425064086918),
                'zoom': 15,
                key: DG.config.key || 'Your API access key'
            });

            map.addControl(DG.control.traffic());
        });
    </script>
</body>
</html>


================================================
FILE: src/DGTrafficControl/lang/ar.js
================================================
DG.Control.Traffic.Dictionary.ar = {
    button_title: 'حركة السير'
};


================================================
FILE: src/DGTrafficControl/lang/cs.js
================================================
DG.Control.Traffic.Dictionary.cs = {
    button_title: 'Zácpy'
};


================================================
FILE: src/DGTrafficControl/lang/en.js
================================================
DG.Control.Traffic.Dictionary.en = {
    button_title: 'Traffic'
};


================================================
FILE: src/DGTrafficControl/lang/es.js
================================================
DG.Control.Traffic.Dictionary.es = {
    button_title: 'Taco'
};


================================================
FILE: src/DGTrafficControl/lang/it.js
================================================
DG.Control.Traffic.Dictionary.it = {
    button_title: 'Colonna'
};


================================================
FILE: src/DGTrafficControl/lang/ru.js
================================================
DG.Control.Traffic.Dictionary.ru = {
    button_title: 'Пробки'
};


================================================
FILE: src/DGTrafficControl/skin/basic/less/dg-control-round.less
================================================
.dg-control-round__icon_name_traffic {
    &:after {
        .notRepeatableBgWithSizes('DGRoundControl__trafficIcon');
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        margin: auto;
        content: '';
    }

    .no-touch &:hover:after,
    &:active:after {
        .notRepeatableBg('DGRoundControl__trafficIconHover');
    }

    .dg-control-round__icon_state_active&:after,
    .no-touch .dg-control-round__icon_state_active&:hover:after,
    .dg-control-round__icon_state_active&:active:after {
        background-image: none;
    }
}


================================================
FILE: src/DGTrafficControl/skin/basic/less/dg-traffic-control.ie.less
================================================
.dg-traffic-control {
    .no-touch &_color_green {
        background: #3fc03b !important;
        font-weight: bold;
    }

    .no-touch &_color_yellow {
        background: #f3b223 !important;
        font-weight: bold;
    }

    .no-touch &_color_red {
        background: #eb240c !important;
        font-weight: bold;
    }
}


================================================
FILE: src/DGTrafficControl/skin/basic/less/dg-traffic-control.less
================================================
a.dg-traffic-control {
    z-index: 0;
    color: #f2f2f2;
    text-decoration: none;
    text-shadow: 0 1px 2px rgba(0, 0, 0, .3);
    font: normal 15px/32px 'Arial narrow', Arial, sans-serif;

    &_color_green:after,
    &_color_yellow:after,
    &_color_red:after {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        z-index: -1;
        margin: auto;
        width: 22px;
        height: 22px;
        border-radius: 50%;
        box-shadow: inset 0 1px 0 0 rgba(0, 0, 0, .2), 0 1px 0 0 #fff;
    }

    .no-touch &:hover {
        color: #f2f2f2;
    }

    .no-touch &_color_green:hover:after,
    .no-touch &_color_yellow:hover:after,
    .no-touch &_color_red:hover:after {
        width: 22px;
        height: 22px;
    }

    &_color_green:after {
        background: #3fc03b;
    }

    .no-touch &_color_green:hover:after,
    &_color_green:active:after {
        background: linear-gradient(to top, #2aa731, #53e13a) #3ec435;
    }

    &_color_yellow:after {
        background: #f3b223;
    }

    .no-touch &_color_yellow:hover:after,
    &_color_yellow:active:after {
        background: linear-gradient(to top, #ef931b, #f7be26) #f4a820;
    }

    &_color_red:after {
        background: #eb240c;
    }

    .no-touch &_color_red:hover:after,
    &_color_red:active:after {
        background: linear-gradient(to top, #c01c0a, #f73416) #db2811;
    }
}


================================================
FILE: src/DGTrafficControl/src/Control.Traffic.js
================================================
DG.Control.Traffic = DG.RoundControl.extend({
    options: {
        position: 'topright',
        iconClass: 'traffic'
    },

    statics: {
        Dictionary: {}
    },

    initialize: function(options) {
        this._trafficClass = 'dg-traffic-control';
        this._controlHideClass = 'dg-control-round_is-hidden_true';

        DG.setOptions(this, options);
        DG.extend(this, {
            _active: false,
            _trafficLayer: null
        }).on(this._controlEvents, this);
    },

    _controlEvents: {
        add: function() {
            this._trafficLayer = DG.traffic();
            this._map.on('zoomend projectchange projectleave', this._updateControlVisibility, this);
        },
        click: function() {
            this._active = !this._active;

            if (this._active) {
                this.setState('active');
                this._showTraffic();
            } else {
                this.setState('');
                this._hideTraffic();
            }
        },
        remove: function() {
            this.off(this._controlEvents, this);
            this._map.off('zoomend projectchange projectleave', this._updateControlVisibility, this);
            if (this._active) {
                this._map.removeLayer(this._trafficLayer);
                this._active = false;
            }
            this._trafficLayer = null;
        }
    },

    _showTraffic: function() { // ()
        this._updateTrafficScore();
        this._map.addLayer(this._trafficLayer);
    },

    _hideTraffic: function() { // ()
        this._handleDom('remove');
        this._map.removeLayer(this._trafficLayer);
    },

    _handleDom: function(method, score) {
        var a = this._link;

        a.innerHTML = isNaN(score) ? '' : score;
        DG.DomUtil[method + 'Class'](a, this._trafficClass);
        DG.DomUtil[method + 'Class'](a, this._trafficClass + '_color_' + this._scoreRate);
    },

    _getTrafficColor: function(score) { // (Number) -> String
        var result = 'green';

        if (score > 7) {
            result = 'red';
        } else if (score > 4) {
            result = 'yellow';
        }

        return result;
    },

    _updateControlVisibility: function() {
        var project = this._map.projectDetector.getProject(),
            projectHasTraffic = project && project.traffic,
            method = ((this._map.getZoom() < DG.config.trafficLayerMinZoom) ||
            (!projectHasTraffic)) ? 'addClass' : 'removeClass';

        DG.DomUtil[method](this._container, this._controlHideClass);
        if (this._active && projectHasTraffic) {
            this._updateTrafficScore();
        }
    },

    _updateTrafficScore: function() {
        var self = this;

        this._getTrafficScore().then(function(score) {
            score = parseInt(score, 10); // sometimes webapi returns something like '5,+'

            self._scoreRate = self._getTrafficColor(score);
            self._handleDom('add', score);
        });
    },

    _getTrafficScore: function() { // () -> Promise
        var url = DG.Util.template(
            DG.config.protocol + DG.config.trafficScoreServer,
            {
                s: this._trafficLayer.getSubdomain(),
                projectCode: this._map.projectDetector.getProject().code
            }
        );

        return DG.ajax(url, {type: 'get'});
    },

    _renderTranslation: function() { // ()
        this._link.title = this.t('button_title');
    }
});

DG.control.traffic = function(options) {
    return new DG.Control.Traffic(options);
};

DG.Map.mergeOptions({
    trafficControl: false
});

DG.Map.addInitHook(function() {
    if (this.options.trafficControl) {
        this.trafficControl = DG.control.traffic(this.options.trafficControl);
        this.addControl(this.trafficControl);
    }
});


================================================
FILE: src/DGTrafficControl/test/TrafficControlSpec.js
================================================
describe('DG.TrafficControl', function() {
    var controlClass = 'dg-control-round__icon_name_traffic',
        controlParentActiveClass = 'dg-control-round_state_active',
        controlParentHiddenClass = 'dg-control-round_is-hidden_true',

        centerNsk = [55.017493, 82.819576],
        centerSpb = [59.937706, 30.13249],
        centerWithoutProject = [77.81307220458986, 55.363990665081126]; // севернее Новой земли

    after(function () {
        controlClass = controlParentActiveClass = controlParentHiddenClass = centerNsk = null;
        centerSpb = centerWithoutProject = null;
    });

    describe('common traffic control test', function() {
        var mapContainer,
            map,
            control,
            trafficControl,
            controlParent;

        before(function () {
            mapContainer = document.createElement('div');
            map = new DG.Map(mapContainer, {
                center: centerSpb,
                zoom: 15,
                key: window.__karma__.config.secretKey,
            });

            control = mapContainer.getElementsByClassName(controlClass);
            trafficControl = DG.control.traffic();

            document.body.appendChild(mapContainer);
            map.addControl(trafficControl);
        });

        after(function () {
            map.remove();
            document.body.removeChild(mapContainer);
            mapContainer = map = control = trafficControl = controlParent = null;
        });

        describe('module init', function () {
            it('traffic control show', function () {
                expect(control.length).to.be(1);

                control = control[0];
                controlParent = control.parentElement;
            });

            it('remove hide class from control parent element', function () {
                expect(controlParent.className).not.contain(controlParentHiddenClass);
            });
        });

        describe('turn on control', function () {
            before(function () {
                happen.click(controlParent);
            });

            it('add active class to control parent element', function () {
                expect(controlParent.className).to.contain(controlParentActiveClass);
            });

            it('add traffic layer to map', function () {
                expect(map.hasLayer(trafficControl._trafficLayer)).to.be(true);
            });
        });

        describe('turn off control', function () {
            before(function () {
                happen.click(controlParent);
            });

            it('remove active class from control parent element', function () {
                expect(controlParent.className).not.contain(controlParentActiveClass);
            });

            it('remove traffic layer from map', function () {
                expect(map.hasLayer(trafficControl._trafficLayer)).to.be(false);
            });
        });

        describe('traffic point request', function () {
            var xhr, center, zoom, requests;

            before(function () {
                zoom = map.getZoom();
                center = map.getCenter();
                xhr = sinon.useFakeXMLHttpRequest();
                requests =  [];

                xhr.onCreate = function (xhr) {
                    requests.push(xhr);
                };

                happen.click(controlParent);

            });

            after(function () {
                xhr.restore();
                map.setView(center, zoom);
                happen.click(controlParent);
            });

            it('traffic points request called', function () {
                var urlRE = new RegExp('http://traffic\\d+.maps.2gis.com/\\w+/meta/score/0/');
                expect(urlRE.test(requests[0].url)).to.be(true);
            });
        });

        describe('traffic point timer request', function () {
            var xhr, center, zoom, requests, clock;

            before(function () {
                zoom = map.getZoom();
                center = map.getCenter();
                xhr = sinon.useFakeXMLHttpRequest();
                clock = sinon.useFakeTimers();
                requests =  [];

                xhr.onCreate = function (xhr) {
                    requests.push(xhr);
                };

                happen.click(controlParent);

            });

            after(function () {
                xhr.restore();
                clock.restore();
                map.setView(center, zoom);
                happen.click(controlParent);
            });

            it('traffic points update request called', function () {
                var urlRE = new RegExp('http://traffic\\d+.maps.2gis.com/\\w+/meta/speed/time/');
                clock.tick(DG.config.trafficLayerUpdateInterval + 1);
                expect(urlRE.test(requests[1].url)).to.be(true);
            });
        });
    });

    describe('traffic test on project leave/enter/change', function () {
        var mapContainer,
            map,
            control,
            trafficControl,
            controlParent;

        beforeEach(function () {
            mapContainer = document.createElement('div');
            map = new DG.Map(mapContainer, {
                center: centerSpb,
                zoom: 15,
                key: window.__karma__.config.secretKey,
            });

            trafficControl = DG.control.traffic();

            document.body.appendChild(mapContainer);
            map.addControl(trafficControl);

            control = mapContainer.getElementsByClassName(controlClass)[0];
            controlParent = control.parentElement;
        });

        afterEach(function () {
            map.remove();
            document.body.removeChild(mapContainer);
            mapContainer = map = control = trafficControl = controlParent = null;
        });

        describe('with traffic off', function () {
            // traffic layer is off after map initialization

            it('control parent haven\'t active and hide classes', function () {
                expect(controlParent.className).not.contain(controlParentActiveClass);
                expect(controlParent.className).not.contain(controlParentHiddenClass);
            });

            it('add hide class to control parent element', function (done) {
                var onProjectLeave = function (ev) {
                    map.off('projectleave', onProjectLeave);
                    expect(controlParent.className).to.contain(controlParentHiddenClass);
                    done();
                };

                map.on('projectleave', onProjectLeave);
                map.setView(centerWithoutProject, 15, {animate: false});
            });

            it('remove hide class and control doesn\'t have active class', function (done) {
                var onProjectChange = function (ev) {
                    map.off('projectchange', onProjectChange);
                    expect(controlParent.className).not.contain(controlParentHiddenClass);
                    expect(controlParent.className).not.contain(controlParentActiveClass);
                    done();
                };

                map.setView(centerWithoutProject, 15, {animate: false});
                map.on('projectchange', onProjectChange);
                map.setView(centerSpb, 15, {animate: false});
            });
        });

        describe('with traffic on', function () {
            beforeEach(function () {
                // traffic layer is on, click on traffic control
                happen.click(controlParent);
            });

            it('control parent have active class', function () {
                expect(controlParent.className).to.contain(controlParentActiveClass);
            });

            // skipped due to unstable behavior on map.remove() after this test
            it.skip('add hide class to control parent element', function (done) {
                var onProjectLeave = function (ev) {
                    map.off('projectleave', onProjectLeave);
                    expect(controlParent.className).to.contain(controlParentHiddenClass);
                    done();
                };

                map.on('projectleave', onProjectLeave);
                map.setView(centerWithoutProject, 15, {animate: false});
            });

            it('remove hide class and control has active class, ', function (done) {
                var onProjectChange = function (ev) {
                    map.off('projectchange', onProjectChange);
                    expect(controlParent.className).not.contain(controlParentHiddenClass);
                    expect(controlParent.className).to.contain(controlParentActiveClass);
                    expect(map.hasLayer(trafficControl._trafficLayer)).to.be(true);
                    done();
                };

                map.setView(centerWithoutProject, 15, {animate: false});
                map.on('projectchange', onProjectChange);
                map.setView(centerSpb, 15, {animate: false});
            });

            it('control parent element have active class', function () {
                map.setView(centerNsk, 15, {animate: false});
                expect(controlParent.className).to.contain(controlParentActiveClass);
            });
        });

        describe('traffic test on project change', function () {
            describe('with traffic off', function () {
                    // traffic layer is off after map initialization

                it('control parent element haven\'t active class', function () {
                    map.setView(centerNsk, 15, {animate: false});
                    expect(controlParent.className).not.contain(controlParentActiveClass);
                });
            });

            describe('with traffic on', function () {
                beforeEach(function () {
                    // traffic layer is on, click on traffic control
                    happen.click(controlParent);
                    control.innerHTML = -50;
                });

                it('control parent element have active class', function () {
                    map.setView(centerNsk, 15, {animate: false});
                    expect(controlParent.className).to.contain(controlParentActiveClass);
                });

                it('update traffic balls in control', function () {
                    expect(control.innerHTML).not.be(-50);
                });
            });
        });
    });
});


================================================
FILE: src/DGWkt/DGWkt.js
================================================
DG.Wkt = {};

DG.Wkt.toGeoJSON = function (data) {
    if (DG.Util.isArray(data)) {
        data = data[0];
    }
    var parts = data.split(';');
    data = parts.pop();

    var i = 0,
        srid = (parts.shift() || '').split('=').pop();

    function $(re) {
        var match = data.substring(i).match(re);
        if (!match) {
            return null;
        }
        else {
            i += match[0].length;
            return match[0];
        }
    }

    function crs(obj) {
        if (obj && srid.match(/\d+/)) {
            obj.crs = {
                type: 'name',
                'properties': {
                    name: 'urn:ogc:def:crs:EPSG::' + srid
                }
            };
        }

        return obj;
    }

    function white() { $(/^\s*/); }

    function multicoords() {
        white();
        var depth = 0, rings = [], stack = [rings],
            pointer = rings, elem;
        while (elem =
            $(/^(\()/) ||
            $(/^(\))/) ||
            $(/^(\,)/) ||
            $(/^[-+]?([0-9]*\.[0-9]+|[0-9]+)/)) {
            if (elem === '(') {
                stack.push(pointer);
                pointer = [];
                stack[stack.length - 1].push(pointer);
                depth++;
            } else if (elem === ')') {
                pointer = stack.pop();
                depth--;
                if (depth === 0) {
                    break;
                }
            } else if (elem === ',') {
                pointer = [];
                stack[stack.length - 1].push(pointer);
            } else {
                pointer.push(parseFloat(elem));
            }
            white();
        }
        stack.length = 0;
        if (depth !== 0) {
            return null;
        }
        return rings;
    }

    function coords() {
        var list = [], item, pt;
        while (pt =
            $(/^[-+]?([0-9]*\.[0-9]+|[0-9]+)/) ||
            $(/^(\,)/)) {
            if (pt === ',') {
                list.push(item);
                item = [];
            } else {
                if (!item) {
                    item = [];
                }
                item.push(parseFloat(pt));
            }
            white();
        }
        if (item) {
            list.push(item);
        }
        return list.length ? list : null;
    }

    function point() {
        if (!$(/^(point)/i)) { return null; }
        white();
        if (!$(/^(\()/)) { return null; }
        var c = coords();
        white();
        if (!$(/^(\))/)) { return null; }
        return {
            type: 'Point',
            coordinates: c[0]
        };
    }

    function multipoint() {
        if (!$(/^(multipoint)/i)) { return null; }
        white();
        var c = multicoords();
        white();
        return {
            type: 'MultiPoint',
            coordinates: c
        };
    }

    function multilinestring() {
        if (!$(/^(multilinestring)/i)) { return null; }
        white();
        var c = multicoords();
        white();
        return {
            type: 'MultiLineString',
            coordinates: c
        };
    }

    function linestring() {
        if (!$(/^(linestring)/i)) { return null; }
        white();
        if (!$(/^(\()/)) { return null; }
        var c = coords();
        if (!$(/^(\))/)) { return null; }
        return {
            type: 'LineString',
            coordinates: c
        };
    }

    function polygon() {
        if (!$(/^(polygon)/i)) { return null; }
        white();
        return {
            type: 'Polygon',
            coordinates: multicoords()
        };
    }

    function multipolygon() {
        if (!$(/^(multipolygon)/i)) { return null; }
        white();
        return {
            type: 'MultiPolygon',
            coordinates: multicoords()
        };
    }

    function geometrycollection() {
        var geometries = [], geometry;

        if (!$(/^(geometrycollection)/i)) { return null; }
        white();

        if (!$(/^(\()/)) { return null; }
        while (geometry = root()) {
            geometries.push(geometry);
            white();
            $(/^(\,)/);
            white();
        }
        if (!$(/^(\))/)) { return null; }

        return {
            type: 'GeometryCollection',
            geometries: geometries
        };
    }

    function root() {
        return point() ||
            linestring() ||
            polygon() ||
            multipoint() ||
            multilinestring() ||
            multipolygon() ||
            geometrycollection();
    }

    return crs(root());
};

DG.Wkt.geoJsonLayer = function (data, opts) {
    return DG.geoJson(DG.Wkt.toGeoJSON(data), opts);
};

DG.Wkt._coordsToLatLngs = function (coords) {
    if (DG.Util.isArray(coords) && !DG.Util.isArray(coords[0])) {
        return [DG.GeoJSON.coordsToLatLng(coords)];
    }

    return coords.map(function (el) {
            return DG.Wkt._coordsToLatLngs(el);
        })
        .reduce(function (arr, coord) {
            return arr.concat(coord);
        });
};

DG.Wkt.toLatLngs = function (data) {
    if (!DG.Util.isArray(data)) {
        data = [data];
    }

    return data.map(function (el) {
        var coords = DG.Wkt.toGeoJSON(el).coordinates;

        return DG.Wkt._coordsToLatLngs(coords);
    }).reduce(function (arr, coord) {
        return arr.concat(coord);
    });
};

DG.Wkt.toPoints = function (data) {
    return DG.Wkt.toGeoJSON(data).coordinates;
};

DG.Wkt.pointsToLatLngOnMap = function (wkt, map) {
    return (function parsePoints(points) {
        return (Array.isArray(points) && Array.isArray(points[0])) ?
            points.map(parsePoints) :
            map.containerPointToLatLng(points);
    })(DG.Wkt.toPoints(wkt));
};


================================================
FILE: src/DGWkt/demo/index.html
================================================
<!DOCTYPE html>
<html>
<head>
    <title>DGWkt demo</title>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <script src="http://maps.api.2gis.ru/2.0/loader.js"></script>
    <style type="text/css">
        html,body { height: 100%; margin: 0; padding: 0; }
        #map { width: 100%; height: 100%; }
    </style>
</head>
<body>

<div id="map"</div>

<script type="text/javascript">
    DG.then(function () {

        var map = new DG.Map('map', {
                center: new DG.LatLng(55.0412876099625, 82.9175228440822),
                zoom: 17,
                key: DG.config.key || 'Your API access key'
            }),
            converter = function (coords) {
                return map.containerPointToLatLng(coords);
            };

        DG.Wkt.geoJsonLayer('POLYGON((82.916999581655 55.0421363815388, 82.9175228440822 55.0401876099625, 82.9180633669606 55.0402351774059, 82.9175402952564 55.0421841282563,82.916999581655 55.0421363815388))').addTo(map);

        DG.Wkt.geoJsonLayer('POINT(82.918299581655 55.0414363815388)').addTo(map);

        DG.Wkt.geoJsonLayer('POINT (300 100)', {
            coordsToLatLng: converter
        }).addTo(map);

        DG.Wkt.geoJsonLayer('LINESTRING (300 100, 100 300, 400 400)', {
            coordsToLatLng: converter
        }).addTo(map);

        DG.Wkt.geoJsonLayer('POLYGON ((300 100, 400 400, 200 400, 100 200, 300 100))', {
            coordsToLatLng: converter
        }).addTo(map);

        DG.Wkt.geoJsonLayer('POLYGON ((850 100, 950 450, 650 400, 600 200, 850 100), (700 300, 850 350, 800 200, 700 300))', {
            style: {color: 'red'},
            coordsToLatLng: converter
        }).addTo(map);

        DG.Wkt.geoJsonLayer('MULTIPOINT (1000 400, 1400 300, 1200 200, 1300 100)', {
            coordsToLatLng: converter
        }).addTo(map);

        DG.Wkt.geoJsonLayer('MULTILINESTRING ((600 100, 700 200, 600 400), (900 400, 800 300, 900 200, 800 100))', {
            coordsToLatLng: converter
        }).addTo(map);

        DG.Wkt.geoJsonLayer('MULTIPOLYGON (((1300 200, 1450 400, 1100 400, 1300 200)), ((1150 50, 1400 100, 1100 200, 1150 100, 1150 50)))', {
            style: {color: 'orange'},
            coordsToLatLng: converter
        }).addTo(map);

        DG.Wkt.geoJsonLayer('MULTIPOLYGON (((1800 400, 1600 450, 1850 300, 1800 400)), ((1600 350, 1500 300, 1500 100, 1700 50, 1850 200, 1600 350), (1700 200, 1600 150, 1600 250, 1700 200)))', {
            coordsToLatLng: converter,
            style: {color: 'green'}
        }).addTo(map);

        DG.Wkt.geoJsonLayer('GEOMETRYCOLLECTION(MULTIPOINT(100 60, 70 300), LINESTRING(100 60, 70 100, 70 300))', {
            coordsToLatLng: converter,
            style: {color: 'grey'}
        }).addTo(map);

    });
</script>

</body>
</html>


================================================
FILE: src/DGWkt/test/DGWktSpec.js
================================================
describe('DG.Wkt', function() {
    describe('check init', function() {
        it('should be DG.Wkt object', function() {
            expect(DG.Wkt).to.be.a('object');
        });
    });

    describe('#geoJsonLayer', function() {
        it('should return DG.GeoJSON', function() {
            expect(DG.Wkt.geoJsonLayer('POLYGON((82.916999581655 55.0421363815388, 82.9175228440822 55.0401876099625, 82.9180633669606 55.0402351774059, 82.9175402952564 55.0421841282563,82.916999581655 55.0421363815388))'))
                .to.be.a(DG.GeoJSON);
        });
    });

    describe('#toPoints', function() {
        it('should equel example points', function() {
            var points = [
                    [1, 2],
                    [5, 10],
                    [8, 7]
                ],
                example,
                res;

            example = 'POLYGON((';
            example += points.map(function(el) {
                return el.join(' ')
            }).join(', ');
            example += '))';

            res = DG.Wkt.toPoints(example);

            expect(res).to.be.a(Array);
            expect(res[0]).to.eql(points);
        });
    });

    describe('#pointsToLatLngOnMap', function() {
        var map;

        before(function() {
            map = new DG.Map(document.createElement('div'), {
                center: [55.017493, 82.819576],
                zoom: 15,
            });
        });

        after(function() {
            map = null;
        });

        it('should return Array of DG.LatLng', function() {
            var example = 'POLYGON((1 2, 5 10, 8 7))',
                res;

            res = DG.Wkt.pointsToLatLngOnMap(example, map);

            expect(res).to.be.a(Array);
            expect(res[0]).to.be.a(Array);

            res[0].forEach(function(el) {
                expect(el).to.be.a(DG.LatLng);
            });
        });
    });
});


================================================
FILE: src/DGWkt/test/DGWktToGeoJSONSpec.js
================================================
describe('DG.Wkt#toLatlngs', function() {
    // test cases took from https://github.com/mapbox/wellknown

    it('POINT (1 1)', function() {
        expect(DG.Wkt.toGeoJSON('POINT (1 1)')).to.be.eql({
            type: 'Point',
            coordinates: [1, 1]
        });
    });

    it('POINT(1 1)', function() {
        expect(DG.Wkt.toGeoJSON('POINT(1 1)')).to.be.eql({
            type: 'Point',
            coordinates: [1, 1]
        });
    });

    it('POINT\n\r(1 1))', function() {
        expect(DG.Wkt.toGeoJSON('POINT\n\r(1 1)')).to.be.eql({
            type: 'Point',
            coordinates: [1, 1]
        });
    });

    it('POINT(1.1 1.1)', function() {
        expect(DG.Wkt.toGeoJSON('POINT(1.1 1.1)')).to.be.eql({
            type: 'Point',
            coordinates: [1.1, 1.1]
        });
    });

    it('point(1.1 1.1)', function() {
        expect(DG.Wkt.toGeoJSON('point(1.1 1.1)')).to.be.eql({
            type: 'Point',
            coordinates: [1.1, 1.1]
        });
    });

    it('point(1 2 3)', function() {
        expect(DG.Wkt.toGeoJSON('point(1 2 3)')).to.be.eql({
            type: 'Point',
            coordinates: [1, 2, 3]
        });
    });

    it('LINESTRING (30 10, 10 30, 40 40)', function() {
        expect(DG.Wkt.toGeoJSON('LINESTRING (30 10, 10 30, 40 40)')).to.be.eql({
            type: 'LineString',
            coordinates: [[30, 10], [10, 30], [40, 40]]
        });
    });

    it('LINESTRING(30 10, 10 30, 40 40)', function() {
        expect(DG.Wkt.toGeoJSON('LINESTRING(30 10, 10 30, 40 40)')).to.be.eql({
            type: 'LineString',
            coordinates: [[30, 10], [10, 30], [40, 40]]
        });
    });

    it('LineString(30 10, 10 30, 40 40)', function() {
        expect(DG.Wkt.toGeoJSON('LineString(30 10, 10 30, 40 40)')).to.be.eql({
            type: 'LineString',
            coordinates: [[30, 10], [10, 30], [40, 40]]
        });
    });

    it('LINESTRING (1 2 3, 4 5 6)', function() {
        expect(DG.Wkt.toGeoJSON('LINESTRING (1 2 3, 4 5 6)')).to.be.eql({
            type: 'LineString',
            coordinates: [[1, 2, 3], [4, 5, 6]]
        });
    });

    it('POLYGON ((30 10, 10 20, 20 40, 40 40, 30 10))', function() {
        expect(DG.Wkt.toGeoJSON('POLYGON ((30 10, 10 20, 20 40, 40 40, 30 10))')).to.be.eql({
            type: 'Polygon',
            coordinates: [[[30, 10], [10, 20], [20, 40], [40, 40], [30, 10]]]
        });
    });

    it('POLYGON((30 10, 10 20, 20 40, 40 40, 30 10))', function() {
        expect(DG.Wkt.toGeoJSON('POLYGON((30 10, 10 20, 20 40, 40 40, 30 10))')).to.be.eql({
            type: 'Polygon',
            coordinates: [[[30, 10], [10, 20], [20, 40], [40, 40], [30, 10]]]
        });
    });

    it('POLYGON ((35 10, 10 20, 15 40, 45 45, 35 10),(20 30, 35 35, 30 20, 20 30))', function() {
        expect(DG.Wkt.toGeoJSON('POLYGON ((35 10, 10 20, 15 40, 45 45, 35 10),(20 30, 35 35, 30 20, 20 30))')).to.be.eql({
            type: 'Polygon',
            coordinates:
                [
                    [
                        [ 35, 10 ],
                        [ 10, 20 ],
                        [ 15, 40 ],
                        [ 45, 45 ],
                        [ 35, 10 ]
                    ], [
                    [ 20, 30 ],
                    [ 35, 35 ],
                    [ 30, 20 ],
                    [ 20, 30 ]
                ]
                ]
        });
    });

    it('MULTIPOINT (1 1, 2 3)', function() {
        expect(DG.Wkt.toGeoJSON('MULTIPOINT (1 1, 2 3)')).to.be.eql({
            type: 'MultiPoint',
            coordinates: [[1, 1], [2, 3]]
        });
    });

    it('MultiPoint (1 1, 2 3)', function() {
        expect(DG.Wkt.toGeoJSON('MultiPoint (1 1, 2 3)')).to.be.eql({
            type: 'MultiPoint',
            coordinates: [[1, 1], [2, 3]]
        });
    });

    it('MULTILINESTRING ((30 10, 10 30, 40 40), (30 10, 10 30, 40 40))', function() {
        expect(DG.Wkt.toGeoJSON('MULTILINESTRING ((30 10, 10 30, 40 40), (30 10, 10 30, 40 40))')).to.be.eql({
            type: 'MultiLineString',
            coordinates: [
                [[30, 10], [10, 30], [40, 40]],
                [[30, 10], [10, 30], [40, 40]]]
        });
    });

    it('MULTIPOLYGON (((30 20, 10 40, 45 40, 30 20)), ((15 5, 40 10, 10 20, 5 10, 15 5)))', function() {
        expect(DG.Wkt.toGeoJSON('MULTIPOLYGON (((30 20, 10 40, 45 40, 30 20)), ((15 5, 40 10, 10 20, 5 10, 15 5)))')).to.be.eql({
            type: 'MultiPolygon',
            coordinates: [
                [[[30, 20], [10, 40], [45, 40], [30, 20]]],
                [[[15, 5], [40, 10], [10, 20], [5, 10], [15, 5]]]]
        });
    });

    it('MULTIPOLYGON (((-74.03349399999999 40.688348)))', function() {
        expect(DG.Wkt.toGeoJSON('MULTIPOLYGON (((-74.03349399999999 40.688348)))')).to.be.eql(
            {"type":"MultiPolygon","coordinates":[[[[-74.03349399999999,40.688348]]]]}
        );
    });

    it('MULTIPOLYGON (((30 20, 10 40, 45 40, 30 20)), ((15 5, 40 10, 10 20, 5 10, 15 5), (10 10, 15 10, 15 15, 10 10)))', function() {
        expect(DG.Wkt.toGeoJSON('MULTIPOLYGON (((30 20, 10 40, 45 40, 30 20)), ((15 5, 40 10, 10 20, 5 10, 15 5), (10 10, 15 10, 15 15, 10 10)))')).to.be.eql({
            type: 'MultiPolygon',
            coordinates: [
                [[[30, 20], [10, 40], [45, 40], [30, 20]]],
                [
                    [[15, 5], [40, 10], [10, 20], [5, 10], [15, 5]],
                    [[10, 10], [15, 10], [15, 15], [10, 10]]]]
        });
    });
});


================================================
FILE: src/DGWkt/test/DGWktToLatLngsSpec.js
================================================
describe('DG.Wkt#toLatLngs', function() {
    it('POINT (1 1)', function() {
        expect(DG.Wkt.toLatLngs('POINT (1 1)')).to.be.eql([
            {lat: 1, lng: 1}
        ]);
    });

    it('POINT(1 1)', function() {
        expect(DG.Wkt.toLatLngs('POINT(1 1)')).to.be.eql([
            {lat: 1, lng: 1}
        ]);
    });

    it('POINT\n\r(1 1))', function() {
        expect(DG.Wkt.toLatLngs('POINT\n\r(1 1)')).to.be.eql([
            {lat: 1, lng: 1}
        ]);
    });

    it('POINT(1.1 1.1)', function() {
        expect(DG.Wkt.toLatLngs('POINT(1.1 1.1)')).to.be.eql([
            {lat: 1.1, lng: 1.1}
        ]);
    });

    it('point(1.1 1.1)', function() {
        expect(DG.Wkt.toLatLngs('point(1.1 1.1)')).to.be.eql([
            {lat: 1.1, lng: 1.1}
        ]);
    });

    it('point(1 2 3)', function() {
        expect(DG.Wkt.toLatLngs('point(1 2 3)')).to.be.eql([{
            lng: 1,
            lat: 2,
            alt: 3
        }]);
    });

    it('[\'point(1 1)\', \'point(1.1 1.1)\']', function() {
        expect(DG.Wkt.toLatLngs(['point(1 1)', 'point(1.1 1.1)'])).to.be.eql([
            {lat: 1, lng: 1},
            {lat: 1.1, lng: 1.1}
        ]);
    });

    it('LINESTRING (30 10, 10 30, 40 40)', function() {
        expect(DG.Wkt.toLatLngs('LINESTRING (30 10, 10 30, 40 40)')).to.be.eql([
            {lng: 30, lat: 10},
            {lng: 10, lat: 30},
            {lng: 40, lat: 40}
        ])
    });

    it('LINESTRING(30 10, 10 30, 40 40)', function() {
        expect(DG.Wkt.toLatLngs('LINESTRING(30 10, 10 30, 40 40)')).to.be.eql([
            {lng: 30, lat: 10},
            {lng: 10, lat: 30},
            {lng: 40, lat: 40}
        ]);
    });

    it('LineString(30 10, 10 30, 40 40)', function() {
        expect(DG.Wkt.toLatLngs('LineString(30 10, 10 30, 40 40)')).to.be.eql([
            {lng: 30, lat: 10},
            {lng: 10, lat: 30},
            {lng: 40, lat: 40}
        ]);
    });

    it('LINESTRING (1 2 3, 4 5 6)', function() {
        expect(DG.Wkt.toLatLngs('LINESTRING (1 2 3, 4 5 6)')).to.be.eql([
            {lng: 1, lat: 2, alt: 3},
            {lng: 4, lat: 5, alt: 6}
        ]);
    });

    it('POLYGON ((30 10, 10 20, 20 40, 40 40, 30 10))', function() {
        expect(DG.Wkt.toLatLngs('POLYGON ((30 10, 10 20, 20 40, 40 40, 30 10))')).to.be.eql([
            {lng: 30, lat: 10},
            {lng: 10, lat: 20},
            {lng: 20, lat: 40},
            {lng: 40, lat: 40},
            {lng: 30, lat: 10}
        ]);
    });

    it('POLYGON((30 10, 10 20, 20 40, 40 40, 30 10))', function() {
        expect(DG.Wkt.toLatLngs('POLYGON((30 10, 10 20, 20 40, 40 40, 30 10))')).to.be.eql([
            {lng: 30, lat: 10},
            {lng: 10, lat: 20},
            {lng: 20, lat: 40},
            {lng: 40, lat: 40},
            {lng: 30, lat: 10}
        ]);
    });

    it('POLYGON ((35 10, 10 20, 15 40, 45 45, 35 10),(20 30, 35 35, 30 20, 20 30))', function() {
        expect(DG.Wkt.toLatLngs('POLYGON ((35 10, 10 20, 15 40, 45 45, 35 10),(20 30, 35 35, 30 20, 20 30))')).to.be.eql([
            {lng: 35, lat: 10},
            {lng: 10, lat: 20},
            {lng: 15, lat: 40},
            {lng: 45, lat: 45},
            {lng: 35, lat: 10},
            {lng: 20, lat: 30},
            {lng: 35, lat: 35},
            {lng: 30, lat: 20},
            {lng: 20, lat: 30}
        ]);
    });

    it('[\'POLYGON ((30 20, 10 40, 45 40, 30 20))\', \'POLYGON ((15 5, 40 10, 10 20, 5 10, 15 5))\']', function() {
        expect(DG.Wkt.toLatLngs(['POLYGON ((30 20, 10 40, 45 40, 30 20))', 'POLYGON ((15 5, 40 10, 10 20, 5 10, 15 5))'])).to.be.eql([
            {lng: 30, lat: 20},
            {lng: 10, lat: 40},
            {lng: 45, lat: 40},
            {lng: 30, lat: 20},

            {lng: 15, lat: 5},
            {lng: 40, lat: 10},
            {lng: 10, lat: 20},
            {lng: 5, lat: 10},
            {lng: 15, lat: 5}
        ]);
    });

    it('MULTIPOINT (1 1, 2 3)', function() {
        expect(DG.Wkt.toLatLngs('MULTIPOINT (1 1, 2 3)')).to.be.eql([
            {lng: 1, lat: 1},
            {lng: 2, lat: 3}
        ]);
    });

    it('MultiPoint (1 1, 2 3)', function() {
        expect(DG.Wkt.toLatLngs('MultiPoint (1 1, 2 3)')).to.be.eql([
            {lng: 1, lat: 1},
            {lng: 2, lat: 3}
        ]);
    });

    it('MULTILINESTRING ((30 10, 10 30, 40 40), (30 10, 10 30, 40 40))', function() {
        expect(DG.Wkt.toLatLngs('MULTILINESTRING ((30 10, 10 30, 40 40), (30 10, 10 30, 40 40))')).to.be.eql([
            {lng: 30, lat: 10},
            {lng: 10, lat: 30},
            {lng: 40, lat: 40},

            {lng: 30, lat: 10},
            {lng: 10, lat: 30},
            {lng: 40, lat: 40}
        ]);
    });

    it('MULTIPOLYGON (((30 20, 10 40, 45 40, 30 20)), ((15 5, 40 10, 10 20, 5 10, 15 5)))', function() {
        expect(DG.Wkt.toLatLngs('MULTIPOLYGON (((30 20, 10 40, 45 40, 30 20)), ((15 5, 40 10, 10 20, 5 10, 15 5)))')).to.be.eql([
            {lng: 30, lat: 20},
            {lng: 10, lat: 40},
            {lng: 45, lat: 40},
            {lng: 30, lat: 20},

            {lng: 15, lat: 5},
            {lng: 40, lat: 10},
            {lng: 10, lat: 20},
            {lng: 5, lat: 10},
            {lng: 15, lat: 5}
        ]);
    });

    it('MULTIPOLYGON (((-74.03349399999999 40.688348)))', function() {
        expect(DG.Wkt.toLatLngs('MULTIPOLYGON (((-74.03349399999999 40.688348)))')).to.be.eql([
            {lng: -74.03349399999999, lat: 40.688348}
        ]);
    });

    it('MULTIPOLYGON (((30 20, 10 40, 45 40, 30 20)), ((15 5, 40 10, 10 20, 5 10, 15 5), (10 10, 15 10, 15 15, 10 10)))', function() {
        expect(DG.Wkt.toLatLngs('MULTIPOLYGON (((30 20, 10 40, 45 40, 30 20)), ((15 5, 40 10, 10 20, 5 10, 15 5), (10 10, 15 10, 15 15, 10 10)))')).to.be.eql([
            {lng: 30, lat: 20},
            {lng: 10, lat: 40},
            {lng: 45, lat: 40},
            {lng: 30, lat: 20},

            {lng: 15, lat: 5},
            {lng: 40, lat: 10},
            {lng: 10, lat: 20},
            {lng: 5, lat: 10},
            {lng: 15, lat: 5},

            {lng: 10, lat: 10},
            {lng: 15, lat: 10},
            {lng: 15, lat: 15},
            {lng: 10, lat: 10}
        ]);
    });
});


================================================
FILE: src/DGZoomControl/lang/ar.js
================================================
DG.Control.Zoom.Dictionary.ar = {
    zoom_in : '',
    zoom_out : ''
};


================================================
FILE: src/DGZoomControl/lang/cs.js
================================================
DG.Control.Zoom.Dictionary.cs = {
    zoom_in : 'Přiblížit',
    zoom_out : 'Oddálit'
};


================================================
FILE: src/DGZoomControl/lang/en.js
================================================
DG.Control.Zoom.Dictionary.en = {
    zoom_in : 'Zoom in',
    zoom_out : 'Zoom out'
};


================================================
FILE: src/DGZoomControl/lang/es.js
================================================
DG.Control.Zoom.Dictionary.es = {
    zoom_in : 'Acercar',
    zoom_out : 'Alejar'
};


================================================
FILE: src/DGZoomControl/lang/it.js
================================================
DG.Control.Zoom.Dictionary.it = {
    zoom_in : 'Zoom avanti',
    zoom_out : 'Zoom indietro'
};


================================================
FILE: src/DGZoomControl/lang/ru.js
================================================
DG.Control.Zoom.Dictionary.ru = {
    zoom_in : 'Приблизить',
    zoom_out : 'Отдалить'
};


================================================
FILE: src/DGZoomControl/skin/basic/less/dg-zoom-control.less
================================================
.dg-zoom {
    width: 40px;
    height: 74px;
}

.dg-zoom__in {
    position: absolute;
    top: 0;
    left: 0;

    .leaflet-touch &:before {
        position: absolute;
        top: -5px;
        right: -10px;
        bottom: 0;
        left: -10px;
        content: '';
    }

    &:after {
        position: absolute;
        right: 0;
        bottom: -1px;
        left: 0;
        z-index: -1;
        margin: auto;
        width: 12px;
        height: 2px;
        box-shadow: 0 0 3px 2px rgba(0, 0, 0, .3);
        content: '';
    }
}

.dg-zoom__button_type_in {
    &:before,
    .leaflet-touch &:before,
    &:after {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        margin: auto;
        width: 14px;
        height: 2px;
        background-color: #7a7a7a; // 48%
        box-shadow: 0 1px #fff;
        content: '';
    }

    &:after {
        width: 2px;
        height: 14px;
    }

    .no-touch &:hover:before,
    .no-touch &:hover:after {
        background-color: #616161; // 38%
    }

    &:active:before,
    &:active:after,
    .no-touch &:active:before,
    .no-touch &:active:after {
        background-color: #575757; // 34%
    }

    .leaflet-disabled &:before,
    .leaflet-disabled &:after,
    .no-touch .leaflet-disabled &:hover:before,
    .no-touch .leaflet-disabled &:hover:after,
    .leaflet-disabled &:active:before,
    .leaflet-disabled &:active:after {
        box-shadow: none;
    }
}

.dg-zoom__out {
    position: absolute;
    top: 40px;
    right: 0;
    left: 0;
    margin: auto;
    width: 22px;
    height: 22px;

    &:after {
        position: absolute;
        top: -1px;
        right: 0;
        left: 0;
        margin: auto;
        width: 12px;
        height: 2px;
        content: '';
    }
}

.dg-zoom__button_type_out {
    width: 22px;
    height: 22px;

    .leaflet-touch &:before {
        top: -5px;
        right: -19px;
        bottom: -19px;
        left: -19px;
    }

    &:after {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        margin: auto;
        width: 10px;
        height: 2px;
        background: #7a7a7a; // 48%
        box-shadow: 0 1px #fff;
        content: '';
    }

    .no-touch &:hover:after {
        background: #616161; // 38%
    }

    &:active:after,
    .no-touch &:active:after {
        background: #575757; // 34%
    }

    .leaflet-disabled &:after,
    .no-touch .leaflet-disabled &:hover:after,
    .leaflet-disabled &:active:after {
        box-shadow: none;
    }
}


================================================
FILE: src/DGZoomControl/skin/dark/less/dg-zoom-control.less
================================================
.dg-zoom__out {
    box-shadow: 0 2px 3px 0 rgba(0, 0, 0, .3);

    &:after {
        background-color: #3d3d3d; // 24%
    }
}

.dg-zoom__button_type_in {
    .leaflet-disabled &:before,
    .leaflet-disabled &:after,
    .no-touch .leaflet-disabled &:hover:before,
    .no-touch .leaflet-disabled &:hover:after,
    .leaflet-disabled &:active:before,
    .leaflet-disabled &:active:after {
        background-color: #707070; // 44%
    }
}

.dg-zoom__button_type_out {
    .leaflet-disabled &:after,
    .no-touch .leaflet-disabled &:hover:after,
    .leaflet-disabled &:active:after {
        background-color: #707070; // 44%
    }
}


================================================
FILE: src/DGZoomControl/skin/light/less/dg-zoom-control.less
================================================
.dg-zoom__out {
    box-shadow: 0 0 0 1px #fff, 0 2px 3px 0 rgba(0, 0, 0, .3);

    &:after {
        border: solid #fff;
        border-width: 0 1px;
        background-color: #f0f0f0; // 94%
    }
}

.dg-zoom__button_type_in {
    .leaflet-disabled &:before,
    .leaflet-disabled &:after,
    .no-touch .leaflet-disabled &:hover:before,
    .no-touch .leaflet-disabled &:hover:after,
    .leaflet-disabled &:active:before,
    .leaflet-disabled &:active:after {
        background-color: #999; // 60%
    }
}

.dg-zoom__button_type_out {
    .leaflet-disabled &:after,
    .no-touch .leaflet-disabled &:hover:after,
    .leaflet-disabled &:active:after {
        background-color: #999; // 60%
    }
}


================================================
FILE: src/DGZoomControl/src/DGZoomControl.js
================================================
DG.Control.Zoom.include(DG.Locale);
DG.Control.Zoom.Dictionary = {};

DG.Control.Zoom.include({
    onAdd: function(map) {
        var zoomName = 'dg-zoom',
            buttonTemplate = '<div class="dg-control-round__icon ' + zoomName + '__control ' + zoomName + '__button ' + zoomName + '__button_type_{type}"></div>',
            container = DG.DomUtil.create('div', zoomName);

        this._map = map;

        this._zoomInButton = this._createButton(DG.Util.template(buttonTemplate, {type : 'in'}), this.t('zoom_in'), 'dg-control-round ' + zoomName + '__in', container, this._zoomIn, this);
        this._zoomOutButton = this._createButton(DG.Util.template(buttonTemplate, {type : 'out'}), this.t('zoom_out'), 'dg-control-round ' + zoomName + '__out', container, this._zoomOut, this);

        this._updateDisabled();
        map.on('zoomend zoomlevelschange', this._updateDisabled, this);

        return container;
    },

    _originalCreateButton: DG.Control.Zoom.prototype._createButton,

    // set active state control on mobile devices
    _createButton: function() {
        var args = Array.prototype.slice.call(arguments);
        var link = this._originalCreateButton.apply(this, args);

        var icon = link.children[0];
        var linkActiveClass = 'dg-control-round_state_active';
        var iconActiveClass = 'dg-control-round__icon_state_active';

        DG.DomEvent
            .on(link, 'touchstart', function() {
                DG.DomUtil.addClass(link, linkActiveClass);
                DG.DomUtil.addClass(icon, iconActiveClass);
            })
            .on(link, 'touchend touchcancel', function() {
                DG.DomUtil.removeClass(link, linkActiveClass);
                DG.DomUtil.removeClass(icon, iconActiveClass);
            });

        return link;
    },

    _renderTranslation: function() {
        if (!this._zoomInButton || !this._zoomOutButton) {
            return;
        }

        this._zoomInButton.title = this.t('zoom_in');
        this._zoomOutButton.title = this.t('zoom_out');
    }
});


================================================
FILE: src/DGZoomControl/test/DGZoomControlSpec.js
================================================
describe('DG.Zoom', function() {
    var classZoomIn = 'dg-zoom__in',
        classZoomOut = 'dg-zoom__out',
        mapContainer,
        map,
        zoomControl,
        zoomContainer,
        zoomIn,
        zoomOut;

    before(function () {
        zoomControl = DG.control.zoom();
        mapContainer = document.createElement('div');
        map = new DG.Map(mapContainer, {
            center: [54.980206086231, 82.898068362003],
            zoom: 15,
            key: window.__karma__.config.secretKey,
        });
    });

    after(function() {
        map.remove();
        classZoomIn = classZoomOut = map = zoomControl = zoomContainer = zoomIn = zoomOut = null;
    });

    function checkInitControl() {
        before(function() {
            zoomContainer = mapContainer.getElementsByClassName('dg-zoom');
        });

        it('should only one zoom container', function() {
            expect(zoomContainer.length).to.be(1);
            zoomContainer = zoomContainer[0];
        });

        it('should zoom container init zoom in button', function() {
            zoomIn = zoomContainer.getElementsByClassName(classZoomIn);
            expect(zoomIn.length).to.be(1);
            zoomIn = zoomIn[0];
        });

        it('should zoom container init zoom out button', function() {
            zoomOut = zoomContainer.getElementsByClassName(classZoomOut);
            expect(zoomOut.length).to.be(1);
            zoomOut = zoomOut[0];
        });
    }

    describe('check auto init', checkInitControl);

    describe('#remove', function() {
        it('should remove zoom container', function() {
            map.zoomControl.remove();
            expect(mapContainer.getElementsByClassName('dg-zoom').length).to.be(0);
        });
    });

    describe('#addTo', function() {
        before(function() {
            zoomControl.addTo(map);
        });

        describe('check init', checkInitControl);

        describe('check clicks', function() {
            it('should map zoom in', function() {
                map.setZoom(15, {animate: false});
                happen.click(zoomIn);
                expect(map.getZoom()).to.be(16);
            });

            it('should map zoom out', function() {
                map.setZoom(15, {animate: false});
                happen.click(zoomOut);
                expect(map.getZoom()).to.be(14);
            });
        });

        describe('check enable/disable zoom controls', function() {
            it('should disable zoomIn button', function() {
                map.setZoom(map.getMaxZoom(), {animate: false});
                expect(zoomIn.className).contain('leaflet-disabled');
            });


            it('should enable zoomIn button', function() {
                map.zoomOut(1, {animate: false});
                expect(zoomIn.className).not.contain('leaflet-disabled');
            });

            it('should disable zoomOut button', function() {
                map.setZoom(map.getMinZoom(), {animate: false});
                expect(zoomOut.className).contain('leaflet-disabled');
            });

            it('should enable zoomOut button', function() {
                map.zoomIn(1, {animate: false});
                expect(zoomOut.className).not.contain('leaflet-disabled');
            });
        });

        describe('check several controls', function() {
            it.skip('should only one container for one zoom control', function() {
                map.addControl(zoomControl);
                expect(mapContainer.getElementsByClassName('dg-zoom').length).to.be(1);
            });

            it('should two containers for two zoom controls', function() {
                var zoomAnotherControl = DG.control.zoom();
                map.addControl(zoomAnotherControl);
                expect(mapContainer.getElementsByClassName('dg-zoom').length).to.be(2);
                zoomAnotherControl.remove();
            });
        });
    });
});


================================================
FILE: src/copyright.js
================================================
/*
 Maps api created at 2GIS. Build on Leaflet.
 (c) 2013-2016, 2GIS
*/



================================================
FILE: src/doc/en/examples/base.md
================================================
## Basic usage

{toc}

### Description

The following are examples of the basic usage of the map. For more information about the work with the map use the
<a href="/doc/maps/en/manual/dg-loading">Connect API</a> and <a href="/doc/maps/en/manual/map">Map</a> documentation sections.

### Create map

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        DG.map('map', {
            center: [54.98, 82.89],
            zoom: 13
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Map creation</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });
                });
            </script>
        </body>
    </html>

### Create map on demand

Map initialization on demand (useful when displaying the map in a popup window):
<input id="create" type="button" value="Show map" />
<div id="mapBlock"></div>
<script>
    var createButton = document.getElementById('create');

    createButton.onclick = function() {
        var container = document.createElement('div'),
            mapBlock = document.getElementById('mapBlock');

        container.id = 'map1';
        container.style.width = '100%';
        container.style.height = '400px';
        mapBlock.appendChild(container);

        DG.then(function(){
            DG.map('map1', {
                center: [54.98, 82.89],
                zoom: 13
            });
        });

        createButton.onclick = null;
    }
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Create map on demand</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js?lazy=true"></script>
        </head>
        <body>
            <input id="create" type="button" value="Display map" />
            <div id="mapBlock"></div>
            <script>
                var createButton = document.getElementById('create');

                createButton.onclick = function() {
                    var container = document.createElement('div'),
                        mapBlock = document.getElementById('mapBlock');

                    container.id = 'map';
                    container.style.width = '100%';
                    container.style.height = '400px';
                    mapBlock.appendChild(container);

                    DG.then(function(){
                        DG.map('map', {
                            center: [54.98, 82.89],
                            zoom: 13
                        });
                    });
                }
            </script>
        </body>
    </html>

### The use of connection options

The following is an example of calling the map with the following set of options: <code>pkg=basic</code>, <code>skin=light</code>.
As the result we get a build with basic functionality in the light theme. All options can be viewed in the
<a href="/doc/maps/en/manual/dg-loading#connectionoptions">Connection Options</a> section.

    <!DOCTYPE html>
    <html>
        <head>
            <title>Use of connection options</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js?pkg=basic&skin=light"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });
                });
            </script>
        </body>
    </html>

### Change map size

When you click the button, the size of the container changes and the map adjusts to the new size:
<input id="changeSize" type="button" value="Change size" />
<div id="map3" style="width: 100%; height: 200px;"></div>
<script>
    var changeSizeButton = document.getElementById('changeSize');

    DG.then(function() {
        var map,
            enabled = false;

        map = DG.map('map3', {
            center: [54.98, 82.89],
            zoom: 15,
            animate: true
        });

        changeSizeButton.onclick = function() {
            var mapDiv = document.getElementById('map3');
            mapDiv.style.height = (enabled ? '200' : '400') + 'px';
            enabled = !enabled;
            map.invalidateSize();
        }
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Change map size</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <input id="changeSize" type="button" value="Change size" />
            <div id="map" style="width: 100%; height: 200px;"></div>
            <script>
                var changeSizeButton = document.getElementById('changeSize');

                DG.then(function() {
                    var map,
                        enabled = false;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 15,
                        animate: true
                    });

                    changeSizeButton.onclick = function() {
                        var mapDiv = document.getElementById('map');
                        mapDiv.style.height = (enabled ? '200' : '400') + 'px';
                        // map update
                        map.invalidateSize();
                    }
                });
            </script>
        </body>
    </html>

### Disabling interaction options

Example of static map display:

<div id="map4" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        DG.map('map4', {
            center: [54.98, 82.89],
            zoom: 13,
            dragging : false,
            touchZoom: false,
            scrollWheelZoom: false,
            doubleClickZoom: false,
            boxZoom: false,
            geoclicker: false,
            zoomControl: false,
            fullscreenControl: false
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Disabling interaction options</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13,
                        dragging : false,
                        touchZoom: false,
                        scrollWheelZoom: false,
                        doubleClickZoom: false,
                        boxZoom: false,
                        geoclicker: false,
                        zoomControl: false,
                        fullscreenControl: false
                    });
                });
            </script>
        </body>
    </html>

### Determining the user's location

An example of determining the user's geographic location:

<div id="map5" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map;

        map = DG.map('map5', {
            center: [54.98, 82.89],
            zoom: 13
        });

        map.locate({setView: true, watch: true})
            .on('locationfound', function(e) {
                DG.marker([e.latitude, e.longitude]).addTo(map);
            })
            .on('locationerror', function(e) {
                DG.popup()
                  .setLatLng(map.getCenter())
                  .setContent('Location access denied')
                  .openOn(map);
            });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Determination of user's location</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    map.locate({setView: true, watch: true})
                        .on('locationfound', function(e) {
                            DG.marker([e.latitude, e.longitude]).addTo(map);
                        })
                        .on('locationerror', function(e) {
                            DG.popup()
                              .setLatLng(map.getCenter())
                              .setContent('Location access denied')
                              .openOn(map);
                        });
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/en/examples/bounds.md
================================================
## Work with map bounds

{toc}

### Description

The following are examples of limitations of map boundaries and zoom levels. For more information about the work with
the map, see the <a href="/doc/maps/en/manual/map">Map</a> documentation section.

### Limit of boundaries and scale

The restriction of the viewable area by boundaries of Novosibirsk, as well as zoom levels ranging from 10 to 15:

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        DG.map('map', {
            center: [54.98, 82.89],
            zoom: 10,
            maxBounds: [
                [54.8220, 82.4304],
                [55.1372, 83.3505]
            ],
            minZoom: 10,
            maxZoom: 15
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Limitation of boarders and scale</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 10,
                        maxBounds: [
                            [54.8220, 82.4304],
                            [55.1372, 83.3505]
                        ],
                        minZoom: 10,
                        maxZoom: 15
                    });
                });
            </script>
        </body>
    </html>

<!--
### Map with a panel

<style>
    #container {
        height:400px;
        position: relative;
    }
    #content {
        position: absolute;
        background:#000;
        background:rgba(51,51,51,.9);
        width:200px;
        height: 400px;
        z-index: 1000;
    }
</style>
<div id='container'>
    <div id='content'></div>
    <div id="map1" style="width: 100%; height: 400px;"></div>
</div>
<script>
    DG.then(function() {
        var map;
        map = DG.map('map1', {
            center: [55.753559, 37.609218],
            zoom: 10,
            zoomControl: false,
            fullscreenControl: false
        });
        DG.control.zoom({position: 'topright'}).addTo(map);
        map.fitBounds(map.getBounds(), {
            paddingTopLeft: [200, 0]
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Map with a left panel</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
            <style>
                #container {
                    height:400px;
                    position: relative;
                }
                #content {
                    position: absolute;
                    background:#000;
                    background:rgba(51,51,51,.9);
                    width:200px;
                    height: 400px;
                    z-index: 1000;
                }
            </style>
        </head>
        <body>
            <div id='container'>
                <div id='content'></div>
                <div id="map" style="width: 100%; height: 400px;"></div>
            </div>
            <script>
                DG.then(function() {
                    var map;
                    map = DG.map('map', {
                        center: [55.753559, 37.609218],
                        zoom: 10,
                        zoomControl: false,
                        fullscreenControl: false
                    });
                    DG.control.zoom({position: 'topright'}).addTo(map);
                    map.fitBounds(map.getBounds(), {
                        paddingTopLeft: [200, 0]
                    });
                });
            </script>
        </body>
    </html>
-->


================================================
FILE: src/doc/en/examples/controls.md
================================================
## Control elements

{toc}

### Description

The following are examples of adding, placing, and working with control elements. For more information about the work
with control elements use the <a href="/doc/maps/en/manual/controls">Controls</a> section of documentation.

### Hide the default control elements

If you need to obtain a "clear" map, with no extra control elements, then the following example will help you:

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map', {
            center: [54.98, 82.89],
            zoom: 13,
            fullscreenControl: false,
            zoomControl: false
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Hide control elements by default</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13,
                        fullscreenControl: false,
                        zoomControl: false
                    });
                });
            </script>
        </body>
    </html>

### The display of control elements in different parts of the map

<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map1', {
            center: [54.98, 82.89],
            zoom: 13
        });

        DG.control.location({position: 'bottomright'}).addTo(map);
        DG.control.scale().addTo(map);
        DG.control.ruler({position: 'bottomleft'}).addTo(map);
        DG.control.traffic().addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Dislay of control elements in different parts of the map</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    DG.control.location({position: 'bottomright'}).addTo(map);
                    DG.control.scale().addTo(map);
                    DG.control.ruler({position: 'bottomleft'}).addTo(map);
                    DG.control.traffic().addTo(map);
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/en/examples/events.md
================================================
## Processing of events

{toc}

### Description

The following are examples of working with events. For more information go to the
<a href="/doc/maps/en/manual/base-classes#dgevented">DG.Evented</a> and the
<a href="/doc/maps/en/manual/base-classes#events">Events</a> sections of documentation.

### Subscribe to events

Sample subscriptions to various events (click on the marker map, geometry):

You clicked on: <span id="clicked_element">nowhere</span>
<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            clickedElement = document.getElementById('clicked_element'),
            coords = [
                [54.99, 82.88],
                [54.985, 82.94],
                [54.984, 82.925],
                [54.981, 82.928]
            ];

        map = DG.map('map', {
            center: [54.98, 82.89],
            zoom: 13
        });

        map.on('click', function(e) {
            clickedElement.innerHTML = 'map, coorinates ' + e.latlng.lat + ', ' + e.latlng.lng;
        });

        DG.marker([54.98, 82.89])
            .on('click', function() {
                clickedElement.innerHTML = 'marker';
            })
            .addTo(map);

        DG.polygon(coords)
            .on('click', function() {
                clickedElement.innerHTML = 'polygon';
            })
            .addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Subscribe to events</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            You clicked on: <span id="clicked_element">nowhere</span>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        clickedElement = document.getElementById('clicked_element'),
                        coords = [
                            [54.99, 82.88],
                            [54.985, 82.94],
                            [54.984, 82.925],
                            [54.981, 82.928]
                        ];

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    map.on('click', function(e) {
                        clickedElement.innerHTML = 'map, coorinates ' + e.latlng.lat + ', ' + e.latlng.lng;
                    });

                    DG.marker([54.98, 82.89])
                        .on('click', function() {
                            clickedElement.innerHTML = 'marker';
                        })
                        .addTo(map);

                    DG.polygon(coords)
                        .on('click', function() {
                            clickedElement.innerHTML = 'polygon';
                        })
                        .addTo(map);
                });
            </script>
        </body>
    </html>

### Subscribe to changes of 2GIS project

If you change the <a href="/doc/maps/en/manual/map#map-projectdetector">project</a> the boundaries of the current one are highlighted:

<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map, currentProjectBound;

        map = DG.map('map1', {
            center: DG.latLng(54.98, 82.89),
            zoom: 9
        });

        // subscribe to the changes of the current 2GIS project
        map.on('projectchange', function(e) {
            var bounds = e.getProject().bound;
            currentProjectBound = DG.geoJSON(bounds, {
                color:"#f03",
                weight:1
            }).addTo(map);
        });

        // subscribe to the event of leaving a 2GIS proejct
        map.on('projectleave', function(e) {
            if (currentProjectBound) {
                map.removeLayer(currentProjectBound);
            }
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Subscribe to changes of 2GIS project</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map, currentProjectBound;

                    map = DG.map('map', {
                        center: DG.latLng(54.98, 82.89),
                        zoom: 9
                    });

                    // subscribe to the changes of the current 2GIS project
                    map.on('projectchange', function(e) {
                        var bounds = e.getProject().bound;
                        currentProjectBound = DG.geoJSON(bounds, {
                            color:"#f03",
                            weight:1
                        }).addTo(map);
                    });

                    // subscribe to the event of leaving a 2GIS project
                    map.on('projectleave', function(e) {
                        if (currentProjectBound) {
                            map.removeLayer(currentProjectBound);
                        }
                    });
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/en/examples/external-modules.md
================================================
## External modules

{toc}

### Description

The following are examples of connection and usage of external modules. For more information go to the
<a href="/doc/maps/en/manual/dg-external-modules">External Modules</a> section of documentation.

### Clusterer

Example of clusterer enabling. Clusterer is often used to display big amount of markers. The module code and its documentation
is available on <a href="https://github.com/Leaflet/Leaflet.markercluster" target="_blank">GitHub repository</a> of the author.

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<link rel="stylesheet" href="https://unpkg.com/leaflet.markercluster@1.4.1/dist/MarkerCluster.css" />
<link rel="stylesheet" href="https://unpkg.com/leaflet.markercluster@1.4.1/dist/MarkerCluster.Default.css" />
<script src="https://maps.api.2gis.ru/2.0/cluster_realworld.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        // module code loading
        return DG.plugin('https://unpkg.com/leaflet.markercluster@1.4.1/dist/leaflet.markercluster.js');
    }).then(function() {
        map = DG.map('map', {
            center: DG.latLng(54.92, 82.82),
            zoom: 9
        });

        var markers = DG.markerClusterGroup();

        // processing of coordinates for installation of markers
        for (var i = 0; i < addressPoints.length; i++) {
            var a = addressPoints[i];
            var title = a[2];
            var marker = DG.marker([a[0], a[1]], { title: title });
            marker.bindPopup(title);
            markers.addLayer(marker);
        }

        map.addLayer(markers);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Clusterer</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
            <link rel="stylesheet" href="https://unpkg.com/leaflet.markercluster@1.4.1/dist/MarkerCluster.css" />
            <link rel="stylesheet" href="https://unpkg.com/leaflet.markercluster@1.4.1/dist/MarkerCluster.Default.css" />
            <script src="https://maps.api.2gis.ru/2.0/cluster_realworld.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    // module code loading
                    return DG.plugin('https://unpkg.com/leaflet.markercluster@1.4.1/dist/leaflet.markercluster.js');
                }).then(function() {
                    map = DG.map('map', {
                        center: DG.latLng(54.92, 82.82),
                        zoom: 9
                    });

                    var markers = DG.markerClusterGroup();

                    // processing of coordinates for installation of markers
                    for (var i = 0; i < addressPoints.length; i++) {
                        var a = addressPoints[i];
                        var title = a[2];
                        var marker = DG.marker([a[0], a[1]], { title: title });
                        marker.bindPopup(title);
                        markers.addLayer(marker);
                    }

                    map.addLayer(markers);
                });
            </script>
        </body>
    </html>


### Heat map

Example of the heat map enabling. The heat map allows you to visualize the quantitative data depending on
a geographical region. The color intensity for each region depends on the values that correspond to it.

<script src="https://maps.api.2gis.ru/2.0/heat_realworld.js"></script>
<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        // Module code loading
        return DG.plugin('https://unpkg.com/leaflet.heat@0.2.0/dist/leaflet-heat.js');
    }).then(function() {
        map = DG.map('map1', {
            center: DG.latLng(54.89, 82.45),
            zoom: 10
        });

        DG.heatLayer(addressPoints1).addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Heat map</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
            <script src="https://maps.api.2gis.ru/2.0/heat_realworld.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    // Module code loading
                    return DG.plugin('https://unpkg.com/leaflet.heat@0.2.0/dist/leaflet-heat.js');
                }).then(function() {
                    map = DG.map('map', {
                        center: DG.latLng(54.89, 82.45),
                        zoom: 10
                    });

                    DG.heatLayer(addressPoints1).addTo(map);
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/en/examples/geojson.md
================================================
## Work with GeoJSON

{toc}

### Description

The following is an example of working with GeoJSON. For more information go to the
<a href="/doc/maps/en/manual/other-layers#dggeojson">GeoJSON</a> section of documentation.

### Example of usage

Display of objects described in the GeoJSON format:

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map', {
            center: [55.042136, 82.91699],
            zoom: 16
        });

        var data = [
            {
                "type": "Feature",
                "properties": {
                    "info": "Я маркер"
                },
                "geometry": {
                    "type": "Point",
                    "coordinates": [82.91799, 55.043136]
                }
            },
            {
                "type": "Feature",
                "properties": {
                    "info": "Я полигон"
                },
                "geometry": {
                    "type": "Polygon",
                    "coordinates": [
                        [
                            [82.91699, 55.042136],
                            [82.917522, 55.040187],
                            [82.918063, 55.040235],
                            [82.917540, 55.042184],
                            [82.91699, 55.042136]
                        ]
                    ]
                }
            }
        ];

        DG.geoJson(data, {
            onEachFeature: function (feature, layer) {
                layer.bindPopup(feature.properties.info);
            }
        }).addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>GeoJSON</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [55.042136, 82.91699],
                        zoom: 16
                    });

                    var data = [
                        {
                            "type": "Feature",
                            "properties": {
                                "info": "I am a marker"
                            },
                            "geometry": {
                                "type": "Point",
                                "coordinates": [82.91799, 55.043136]
                            }
                        },
                        {
                            "type": "Feature",
                            "properties": {
                                "info": "I am a polyline"
                            },
                            "geometry": {
                                "type": "Polygon",
                                "coordinates": [
                                    [
                                        [82.91699, 55.042136],
                                        [82.917522, 55.040187],
                                        [82.918063, 55.040235],
                                        [82.917540, 55.042184],
                                        [82.91699, 55.042136]
                                    ]
                                ]
                            }
                        }
                    ];

                    DG.geoJson(data, {
                        onEachFeature: function (feature, layer) {
                            layer.bindPopup(feature.properties.info);
                        }
                    }).addTo(map);
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/en/examples/markers.md
================================================
## Work with markers

{toc}

### Description

The following are examples of usage of markers. A marker can be added to the map using the <code>addTo()</code> method,
but if you are planning to work with a group of markers, we recommend you to use <code>FeatureGroup</code>
(see the Processing of events of markers group, and Multiple markers display and adjustment of boundaries sections).
For more information about markers, go to the <a href="/doc/maps/en/manual/markers">Markers</a> section of documentation.

### A marker with a popup

A marker, clicking on which you open a popup with the information:

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function () {
        var map = DG.map('map', {
            center: [54.98, 82.89],
            zoom: 15
        });

        DG.marker([54.98, 82.89]).addTo(map).bindPopup('I am a popup!');
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>A marker with a popup</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 15
                    });

                    DG.marker([54.98, 82.89]).addTo(map).bindPopup('I am a popup!');
                });
            </script>
        </body>
    </html>

### Draggable marker

The marker, which users can drag and drop:

Marker coordinates: <div id="location">54.981, 82.891</div>

<div id="map1" style="width: 100%; height: 400px;"></div>
<script type="text/javascript">
    var locationInfo = document.getElementById('location');
    DG.then(function () {
        var map,
            marker;

        map = DG.map('map1', {
            center: [54.981, 82.891],
            zoom: 15
        });

        marker = DG.marker([54.981, 82.891], {
            draggable: true
        }).addTo(map);

        marker.on('drag', function(e) {
            var lat = e.target._latlng.lat.toFixed(3),
                lng = e.target._latlng.lng.toFixed(3);

            locationInfo.innerHTML = lat + ', ' + lng;
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Draggable marker</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            Marker coordinates: <div id="location">LatLng(54.98, 82.89)</div>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script type="text/javascript">
                var locationInfo = document.getElementById('location');

                DG.then(function () {
                    var map,
                        marker;

                    map = DG.map('map', {
                        center: [54.981, 82.891],
                        zoom: 15
                    });

                    marker = DG.marker([54.981, 82.891], {
                        draggable: true
                    }).addTo(map);

                    marker.on('drag', function(e) {
                        var lat = e.target._latlng.lat.toFixed(3),
                            lng = e.target._latlng.lng.toFixed(3);

                        locationInfo.innerHTML = lat + ', ' + lng;
                    });
                });
            </script>
        </body>
    </html>

### A marker with a custom icon

You can select a custom icon or a simple div element for the marker instead of an image:

<div id="map2" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            myIcon,
            myDivIcon;

        map = DG.map('map2', {
            center: [54.98, 82.89],
            zoom: 13
        });

        myIcon = DG.icon({
            iconUrl: 'https://maps.api.2gis.ru/2.0/example_logo.png',
            iconSize: [48, 48]
        });
        DG.marker([54.98, 82.89], {
            icon: myIcon
        }).addTo(map);

        myDivIcon = DG.divIcon({
            iconSize: [70, 20],
            html: '<b style="color:blue;">HTML-код</b>'
        });
        DG.marker([54.98, 82.87], {
            icon: myDivIcon
        }).addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>A marker with a custom icon</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        myIcon,
                        myDivIcon;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    myIcon = DG.icon({
                        iconUrl: 'https://maps.api.2gis.ru/2.0/example_logo.png',
                        iconSize: [48, 48]
                    });
                    DG.marker([54.98, 82.89], {
                        icon: myIcon
                    }).addTo(map);

                    myDivIcon = DG.divIcon({
                        iconSize: [70, 20],
                        html: '<b style="color:blue;">HTML-код</b>'
                    });
                    DG.marker([54.98, 82.87], {
                        icon: myDivIcon
                    }).addTo(map);
                });
            </script>
        </body>
    </html>

### Open a marker programmatically

It is possible to open a popup on demand. For example, by clicking on a link or button:

<button id='open-popup'>Open popup</button>
<div id="map3" style="width: 100%; height: 400px;"></div>
<script>
    var openPopupBtn = document.getElementById('open-popup');

    DG.then(function() {
        var map,
            marker;

        map = DG.map('map3', {
            center: [54.98, 82.89],
            zoom: 15
        });

        marker = DG.marker([54.98, 82.89]).addTo(map);
        marker.bindPopup('I am a popup!');

        openPopupBtn.onclick = function() {
            marker.openPopup();
        }
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Open a marker programmatically</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <button id='open-popup'>Open popup</button>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                var openPopupBtn = document.getElementById('open-popup');

                DG.then(function() {
                    var map,
                        marker;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 15
                    });

                    marker = DG.marker([54.98, 82.89]).addTo(map);
                    marker.bindPopup('I am a popup!');

                    openPopupBtn.onclick = function() {
                        marker.openPopup();
                    }
                });
            </script>
        </body>
    </html>

### Marker with a tip

The marker has two kinds of tips: a regular and a static ones. Both options are considered in the following example:

<div id="map4" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map4', {
            center: [54.98, 82.89],
            zoom: 15
        });

        DG.marker([54.98, 82.89])
            .addTo(map)
            .bindLabel('I am a static tip!', {
                static: true
            });

        DG.marker([54.98, 82.88])
            .addTo(map)
            .bindLabel('I am a simple tip!');
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Marker with a tip</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 15
                    });

                    DG.marker([54.98, 82.89])
                        .addTo(map)
                        .bindLabel('I am a static tip!', {
                            static: true
                        });

                    DG.marker([54.98, 82.88])
                        .addTo(map)
                        .bindLabel('I am a simple tip!');
                });
            </script>
        </body>
    </html>

### Processing events of the group of markers

When clicking on the marker, the map will be centered in its position:

<div id="map5" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            marker1,
            marker2,
            marker3,
            group;

        map = DG.map('map5', {
            center: [54.98, 82.89],
            zoom: 13
        });

        marker1 = DG.marker([54.96, 82.889]).addTo(map);
        marker2 = DG.marker([54.98, 82.893]).addTo(map);
        marker3 = DG.marker([54.99, 82.896]).addTo(map);

        group = DG.featureGroup([marker1, marker2, marker3]);
        group.addTo(map);
        group.on('click', function(e) {
            map.setView([e.latlng.lat, e.latlng.lng]);
        });
    });
</script>


    <!DOCTYPE html>
    <html>
        <head>
            <title>Processing of events of markers group</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        marker1,
                        marker2,
                        marker3,
                        group;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    marker1 = DG.marker([54.96, 82.889]).addTo(map);
                    marker2 = DG.marker([54.98, 82.893]).addTo(map);
                    marker3 = DG.marker([54.99, 82.896]).addTo(map);

                    group = DG.featureGroup([marker1, marker2, marker3]);
                    group.addTo(map);
                    group.on('click', function(e) {
                        map.setView([e.latlng.lat, e.latlng.lng]);
                    });
                });
            </script>
        </body>
    </html>

### Animated movement of marker

An example of a marker that moves along a given trajectory:
<div id="map6" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            marker;

        map = DG.map('map6', {
            center: [54.98, 82.89],
            zoom: 13
        });

        marker = DG.marker([54.98, 82.89]).addTo(map);

        var increment = 0.001;

        function move() {
            if (!map.getBounds().contains(marker.getLatLng())) {
                increment *= -1;
            }

            var newLat = marker.getLatLng().lat + increment,
                newLng = marker.getLatLng().lng + increment;

            marker.setLatLng([newLat, newLng]);
        }

        setInterval(move, 60);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Animated marker movement</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        marker;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    marker = DG.marker([54.98, 82.89]).addTo(map);

                    var increment = 0.001;

                    function move() {
                        if (!map.getBounds().contains(marker.getLatLng())) {
                            increment *= -1;
                        }

                        var newLat = marker.getLatLng().lat + increment,
                            newLng = marker.getLatLng().lng + increment;

                        marker.setLatLng([newLat, newLng]);
                    }

                    setInterval(move, 60);
                });
            </script>
        </body>
    </html>

### Multiple markers display and adjustment of boundaries

Example of display and hiding of groups of markers with automatic detection of map boundaries:

<input id="show" type="button" value="Show markers" /><input id="hide" type="button" value="Hide markers" />
<div id="map7" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            markers = DG.featureGroup(),
            coordinates = [];

        map = DG.map('map7', {
            center: [54.98, 82.89],
            zoom: 13
        });

        for (var i = 0; i < 100; i++) {
            coordinates[0] = 54.98 + Math.random();
            coordinates[1] = 82.89 + Math.random();
            DG.marker(coordinates).addTo(markers);
        }

        document.getElementById('hide').onclick = hideMarkers;
        document.getElementById('show').onclick = showMarkers;

        function showMarkers() {
            markers.addTo(map);
            map.fitBounds(markers.getBounds());
        };

        function hideMarkers() {
            markers.removeFrom(map);
        };
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Display/removal of several markers, fitBounds</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <input id="hide" type="button" value="hide markers" />
            <input id="show" type="button" value="show markers" />
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
            DG.then(function() {
                var map,
                    markers = DG.featureGroup(),
                    coordinates = [];

                map = DG.map('map', {
                    center: [54.98, 82.89],
                    zoom: 13
                });

                for (var i = 0; i < 100; i++) {
                    coordinates[0] = 54.98 + Math.random();
                    coordinates[1] = 82.89 + Math.random();
                    DG.marker(coordinates).addTo(markers);
                }

                document.getElementById('hide').onclick = hideMarkers;
                document.getElementById('show').onclick = showMarkers;

                function showMarkers() {
                    markers.addTo(map);
                    map.fitBounds(markers.getBounds());
                };

                function hideMarkers() {
                    markers.removeFrom(map);
                };
            });
        </script>
        </body>
    </html>


================================================
FILE: src/doc/en/examples/popups.md
================================================
## Work with popups

{toc}

### Description

The following are examples of usage of pop-ups.
For more information go to the <a href="/doc/maps/en/manual/popup">Popups</a> section of documentation.

### Open a popup by clicking on a marker

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function () {
        var map = DG.map('map', {
            center: [54.98, 82.89],
            zoom: 15
        });

        DG.marker([54.98, 82.89]).addTo(map).bindPopup('I am a popup!');
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Opens a popup when clicking on the marker</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 15
                    });

                    DG.marker([54.98, 82.89]).addTo(map).bindPopup('I am a popup!');
                });
            </script>
        </body>
    </html>

### Open a popup by default and on demand

<input id="showPopup" type="button" value="Open popup" />
<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    var showButton = document.getElementById('showPopup');

    DG.then(function() {
        var map,
            myPopUp;

        map = DG.map('map1', {
            center: [54.98, 82.89],
            zoom: 13
        });

        DG.popup([54.98, 82.89])
            .setLatLng([54.98, 82.89])
            .setContent('I am opened by default')
            .openOn(map);

        myPopUp = DG.popup()
            .setLatLng([54.98, 82.89])
            .setContent('I have been opened on demand and closed the previous popup!');

        showButton.onclick = function() {myPopUp.openOn(map)};
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Open a popup by default and on demand</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <input id="showPopup" type="button" value="Открыть попап" />
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                var showButton = document.getElementById('showPopup');

                DG.then(function() {
                    var map,
                        myPopUp;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    DG.popup([54.98, 82.89])
                        .setLatLng([54.98, 82.89])
                        .setContent('I am opened by default')
                        .openOn(map);

                    myPopUp = DG.popup()
                        .setLatLng([54.98, 82.89])
                        .setContent('I have been opened on demand and closed the previous popup!');

                    showButton.onclick = function() {myPopUp.openOn(map)};
                });
            </script>
        </body>
    </html>

### Add several popups to the map

<div id="map2" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            popups = DG.featureGroup(),
            coordinates = [];

        map = DG.map('map2', {
            center: [54.98, 82.89],
            zoom: 13
        });

        for (var i = 0; i < 10; i++) {
            coordinates[0] = 54.98 - Math.random();
            coordinates[1] = 82.89 + Math.random();
            DG.popup()
                .setLatLng(coordinates)
                .setContent('I am popup №' + i)
                .addTo(popups);
        }

        popups.addTo(map);
        map.fitBounds(popups.getBounds());
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Add several popups to the map</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        popups = DG.featureGroup(),
                        coordinates = [];

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    // create 10 popups in random places and add them to the group
                    for (var i = 0; i < 10; i++) {
                        coordinates[0] = 54.98 - Math.random();
                        coordinates[1] = 82.89 + Math.random();
                        DG.popup()
                            .setLatLng(coordinates)
                            .setContent('I am popup №' + i)
                            .addTo(popups);
                    }

                    popups.addTo(map);

                    // focus the scope on popups
                    map.fitBounds(popups.getBounds());
                });
            </script>
        </body>
    </html>

### The behavior of a popup with the sprawling parameter

<div id="map3" style="width: 300px; height: 150px;"></div>
<input style="width: 300px;" type="button" id="sprawling" value="The popup with enabled sprawling parameter" />
<input style="width: 300px;" type="button" id="no-sprawling" value="Popup without the sprawling parameter" />
<input style="width: 300px;" type="button" id="minWidth" value="Popup with a minimum width of 320px" />
<script>
    DG.then(function () {
        var latLng = DG.latLng([54.98, 82.89]),
            map = DG.map('map3', {
                center: latLng,
                zoom: 13,
                fullscreenControl: false,
                zoomControl: false
            });

        document.getElementById('sprawling').onclick = function () {
            DG.popup({
                maxWidth: 350,
                sprawling: true
            })
            .setLatLng(latLng)
            .setContent('I am a popup!')
            .openOn(map);
        };

        document.getElementById('no-sprawling').onclick = function () {
            DG.popup({
                maxWidth: 350
            })
            .setLatLng(latLng)
            .setContent('I am a popup!')
            .openOn(map);
        };

        document.getElementById('minWidth').onclick = function () {
            DG.popup({
                maxWidth: 350,
                minWidth: 320
            })
            .setLatLng(latLng)
            .setContent('I am a popup!')
            .openOn(map);
        };
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Behaviour of the popup with the sprawling parameter</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 300px; height: 150px;"></div>
            <input style="width: 300px;" type="button" id="sprawling" value="The popup with enabled sprawling parameter" />
            <input style="width: 300px;" type="button" id="no-sprawling" value="Popup without the sprawling parameter" />
            <input style="width: 300px;" type="button" id="minWidth" value="Popup with a minimum width of 320px" />
            <script>
                DG.then(function () {
                    var latLng = DG.latLng([54.98, 82.89]),
                        map;

                    // let's initialize the map with a width of 300 pixels
                    map = DG.map('map', {
                        center: latLng,
                        zoom: 13,
                        fullscreenControl: false,
                        zoomControl: false
                    });

                    // the popup with the enabled sprawling parameter
                    // will strech to the boundaries of the map
                    document.getElementById('sprawling').onclick = function () {
                        DG.popup({
                            maxWidth: 350,
                            sprawling: true
                        })
                        .setLatLng(latLng)
                        .setContent('I am a popup!')
                        .openOn(map);
                    };

                    // the popup with no sprawling parameter
                    // will adjust to the width of the content
                    document.getElementById('no-sprawling').onclick = function () {
                        DG.popup({
                            maxWidth: 350
                        })
                        .setLatLng(latLng)
                        .setContent('I am a popup!')
                        .openOn(map);
                    };

                    // the popup with a minimum width of  320px
                    // will go outside the boundaries of the map
                    document.getElementById('minWidth').onclick = function () {
                        DG.popup({
                            maxWidth: 350,
                            minWidth: 320
                        })
                        .setLatLng(latLng)
                        .setContent('I am a popup!')
                        .openOn(map);
                    };
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/en/examples/vector-layers.md
================================================
## Work with vector layers

{toc}

### Description

The following are basic examples of usage of geometric objects. For more information about the work with vector layers
use the <a href="/doc/maps/en/manual/vector-layers">Vector Layers</a> section of documentation.

### Polyline display

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 500px;"></div>
<script>
    DG.then(function() {
        var map,
            coordinates,
            polyline;

        map = DG.map('map', {
            center: [55.036446, 82.897983],
            zoom: 11
        });

        coordinates = [[55.069288, 82.991367], [55.069288, 82.816615], [55.011648, 82.902103], [54.944714, 82.903152], [54.928935, 82.850967], [54.928541, 82.976280], [54.944517, 82.916541], [55.011704, 82.916885], [55.056508, 82.973514], [55.056508, 82.835498], [55.056705, 82.973857], [55.069288, 82.991367], [55.069288, 82.941928], [55.097193, 82.959094], [55.046282, 82.919956], [55.045692, 82.904163], [55.036446, 82.897983], [55.029756, 82.907596], [55.018932, 82.903819], [55.029362, 82.914119], [55.030543, 82.927165], [55.037823, 82.933345], [55.045101, 82.925105], [55.069681, 82.941928]];

        // create a polyline from an array of geographical points
        polyline = DG.polyline(coordinates, {color: 'blue'}).addTo(map);

        // adjust the center of the map and the scale to make the polyline visible
        map.fitBounds(polyline.getBounds());
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Polyline display</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 500px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        coordinates,
                        polyline;

                    map = DG.map('map', {
                        center: [55.036446, 82.897983],
                        zoom: 11
                    });

                    coordinates = [[55.069288, 82.991367], [55.069288, 82.816615], [55.011648, 82.902103], [54.944714, 82.903152], [54.928935, 82.850967], [54.928541, 82.976280], [54.944517, 82.916541], [55.011704, 82.916885], [55.056508, 82.973514], [55.056508, 82.835498], [55.056705, 82.973857], [55.069288, 82.991367], [55.069288, 82.941928], [55.097193, 82.959094], [55.046282, 82.919956], [55.045692, 82.904163], [55.036446, 82.897983], [55.029756, 82.907596], [55.018932, 82.903819], [55.029362, 82.914119], [55.030543, 82.927165], [55.037823, 82.933345], [55.045101, 82.925105], [55.069681, 82.941928]];

                    // create a polyline from an array of geographical points
                    polyline = DG.polyline(coordinates, {
                        color: 'blue'
                    }).addTo(map);

                    // adjust the center of the map and the scale to make the polyline visible
                    map.fitBounds(polyline.getBounds());
                });
            </script>
        </body>
    </html>

### Display rectangles

<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            coords1 = [[54.98, 82.87], [54.975, 82.91]],
            coords2 = [[54.985, 82.87], [54.982, 82.91]],
            coords3 = [[54.99, 82.87], [54.987, 82.91]],
            rectangles = DG.featureGroup();

        map = DG.map('map1', {
            center: [54.98, 82.89],
            zoom: 14
        });

        // Add rectangles to the group
        DG.rectangle(coords1, {color: "blue"}).addTo(rectangles);
        DG.rectangle(coords2, {color: "red"}).addTo(rectangles);
        DG.rectangle(coords3, {color: "green"}).addTo(rectangles);

        // Add group to the map
        rectangles.addTo(map);

        // Adjust boundaries of the map
        map.fitBounds(rectangles.getBounds());
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Display of rectangles</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        coords1 = [[54.98, 82.87], [54.975, 82.91]],
                        coords2 = [[54.985, 82.87], [54.982, 82.91]],
                        coords3 = [[54.99, 82.87], [54.987, 82.91]],
                        rectangles = DG.featureGroup();

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 14
                    });

                    // Add rectangles to the group
                    DG.rectangle(coords1, {color: "blue"}).addTo(rectangles);
                    DG.rectangle(coords2, {color: "red"}).addTo(rectangles);
                    DG.rectangle(coords3, {color: "green"}).addTo(rectangles);

                    // Add group to the map
                    rectangles.addTo(map);

                    // Adjust boundaries of the map
                    map.fitBounds(rectangles.getBounds());
                });
            </script>
        </body>
    </html>

### Display polygons

<div id="map2" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            coords1 = [
                [54.98, 82.87],
                [54.975, 82.91],
                [54.974, 82.915],
                [54.971, 82.918],
                [54.970, 82.921]
            ],
            coords2 = [
                [54.985, 82.875],
                [54.98, 82.96],
                [54.979, 82.92],
                [54.976, 82.923]
            ],
            coords3 = [
                [54.99, 82.88],
                [54.985, 82.971],
                [54.984, 82.925],
                [54.981, 82.928],
                [54.980, 82.931]
            ],
            polygons = DG.featureGroup();

        map = DG.map('map2', {
            center: [54.98, 82.89],
            zoom: 13
        });

        DG.polygon(coords1, {color: "blue"}).addTo(polygons);
        DG.polygon(coords2, {color: "red"}).addTo(polygons);
        DG.polygon(coords3, {color: "green"}).addTo(polygons);

        polygons.addTo(map);
        map.fitBounds(polygons.getBounds());
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Display polygons</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        coords1 = [
                            [54.98, 82.87],
                            [54.975, 82.91],
                            [54.974, 82.915],
                            [54.971, 82.918],
                            [54.970, 82.921]
                        ],
                        coords2 = [
                            [54.985, 82.875],
                            [54.98, 82.96],
                            [54.979, 82.92],
                            [54.976, 82.923]
                        ],
                        coords3 = [
                            [54.99, 82.88],
                            [54.985, 82.971],
                            [54.984, 82.925],
                            [54.981, 82.928],
                            [54.980, 82.931]
                        ],
                        polygons = DG.featureGroup();

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    // Add polygons to a group
                    DG.polygon(coords1, {color: "blue"}).addTo(polygons);
                    DG.polygon(coords2, {color: "red"}).addTo(polygons);
                    DG.polygon(coords3, {color: "green"}).addTo(polygons);

                    // Add a group to the map
                    polygons.addTo(map);

                    // Adjust the boundaries of the map
                    map.fitBounds(polygons.getBounds());
                });
            </script>
        </body>
    </html>

### Display a circle and a round marker

<div id="map3" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map3', {
            center: [54.98, 82.89],
            zoom: 14
        });

        DG.circle([54.98, 82.89], 200, {color: 'red'}).addTo(map);
        DG.circleMarker([54.985, 82.89]).setRadius(100).addTo(map);
    })
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Display a circle and a round marker</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 14
                    });

                    DG.circle([54.98, 82.89], 200, {color: 'red'}).addTo(map);
                    DG.circleMarker([54.985, 82.89]).setRadius(100).addTo(map);
                })
            </script>
        </body>
    </html>

### Vector layers with tips and pop-ups

<div id="map4" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map4', {
            center: [54.98, 82.89],
            zoom: 14
        });

        DG.circle([54.98, 82.87], 200, {color: 'red'})
            .bindPopup('I am a circle')
            .bindLabel('Click on the circle')
            .addTo(map);

        DG.circleMarker([54.985, 82.89])
            .bindPopup('I am a circle marker')
            .bindLabel('Click on a circle marker')
            .setRadius(100)
            .addTo(map);

        DG.rectangle(
            [[54.98, 82.87], [54.975, 82.91]],
            {color: 'green'})
            .bindPopup('I am a rectangle')
            .bindLabel('Click on a rectangle')
            .addTo(map);

        DG.polygon(
            [[54.985, 82.875], [54.98, 82.96], [54.979, 82.92]],
            {color: 'yellow'})
            .bindPopup('I am a polygon')
            .bindLabel('Click on a polygon')
            .addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Vector layers with tips and pop-ups</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 14
                    });

                    DG.circle([54.98, 82.87], 200, {color: 'red'})
                        .bindPopup('I am a circle')
                        .bindLabel('Click on the circle')
                        .addTo(map);

                    DG.circleMarker([54.985, 82.89])
                        .bindPopup('I am a circle marker')
                        .bindLabel('Click on a circle marker')
                        .setRadius(100)
                        .addTo(map);

                    DG.rectangle(
                        [[54.98, 82.87], [54.975, 82.91]],
                        {color: 'green'})
                        .bindPopup('I am a rectangle')
                        .bindLabel('Click on a rectangle')
                        .addTo(map);

                    DG.polygon(
                        [[54.985, 82.875], [54.98, 82.96], [54.979, 82.92]],
                        {color: 'yellow'})
                        .bindPopup('I am a polygon')
                        .bindLabel('Click on a polygon')
                        .addTo(map);
                });
            </script>
        </body>
    </html>

### Animation of the polyline rendering

<input id="playAnimation" type="button" value="Start animation" />
<div id="map5" style="width: 100%; height: 400px;"></div>
<script>
    var playAnimationButton = document.getElementById('playAnimation');

    DG.then(function() {
        var map = DG.map('map5', {
            center: [54.98, 82.94],
            zoom: 13
        });

        playAnimation.onclick = function() {
            var polyline = DG.polyline([]).addTo(map),
                counter = 0;

            (function draw() {
                polyline.addLatLng([54.98, 82.89 + counter / 10000]);

                if (++counter < 1000) {
                    window.setTimeout(draw, 10);
                } else {
                    counter = 0;
                    draw();
                };
            })();
        }
    })
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Animation of the polyline rendering</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <input id="playAnimation" type="button" value="Start animation" />
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                var playAnimationButton = document.getElementById('playAnimation');

                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.94],
                        zoom: 13
                    });

                    playAnimation.onclick = function() {
                        var polyline = DG.polyline([]).addTo(map),
                            counter = 0;

                        (function draw() {
                            polyline.addLatLng([54.98, 82.89 + counter / 10000]);

                            if (++counter < 1000) {
                                window.setTimeout(draw, 10);
                            } else {
                                counter = 0;
                                draw();
                            };
                        })();
                    }
                })
            </script>
        </body>
    </html>


================================================
FILE: src/doc/en/examples/wkt.md
================================================
## Work with WKT

{toc}

### Description

The following is an example of working with WKT.
For more information go to the <a href="/doc/maps/en/manual/dg-wkt">WKT</a> section of documentation.

### Display of simple vector layers

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            coord1 = 'POLYGON((82.91699 55.042136, 82.917522 55.040187, 82.918063 55.040235, 82.917540 55.042184,82.91699 55.042136))',
            coord2 = 'LINESTRING(82.91799 55.043136, 82.918522 55.041187, 82.919063 55.041235)',
            coord3 = 'POINT(82.914 55.042136)';

        map = DG.map('map', {
            center: [55.042136, 82.91699],
            zoom: 16
        });

        DG.Wkt.geoJsonLayer(coord1).addTo(map);

        DG.Wkt.geoJsonLayer(coord2).addTo(map);

        DG.Wkt.geoJsonLayer(coord3).addTo(map);
    })
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Display of simple vector layers</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        coord1 = 'POLYGON((82.91699 55.042136, 82.917522 55.040187, 82.918063 55.040235, 82.917540 55.042184,82.91699 55.042136))',
                        coord2 = 'LINESTRING(82.91799 55.043136, 82.918522 55.041187, 82.919063 55.041235)',
                        coord3 = 'POINT(82.914 55.042136)';

                    map = DG.map('map', {
                        center: [55.042136, 82.91699],
                        zoom: 16
                    });

                    DG.Wkt.geoJsonLayer(coord1).addTo(map);

                    DG.Wkt.geoJsonLayer(coord2).addTo(map);

                    DG.Wkt.geoJsonLayer(coord3).addTo(map);
                })
            </script>
        </body>
    </html>

### Display of complex vector layers

<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map1', {
            center: [55.041836, 82.91699],
            zoom: 16
        });

        DG.Wkt.geoJsonLayer('MULTIPOLYGON(((82.91699 55.042136, 82.917522 55.040187, 82.918063 55.040235, 82.917540 55.042184,82.91699 55.042136)), ((82.91599 55.041136, 82.916522 55.039187, 82.917063 55.039235, 82.916540 55.041184,82.91599 55.041136)))').addTo(map);
        DG.Wkt.geoJsonLayer('MULTILINESTRING((82.91799 55.043136, 82.918522 55.041187, 82.919063 55.041235), (82.91899 55.044136, 82.919522 55.042187, 82.920063 55.042235))').addTo(map);
        DG.Wkt.geoJsonLayer('MULTIPOINT(82.914 55.042136, 82.915 55.043136, 82.915 55.042136, 82.914 55.043136)').addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Display of compound vector layers</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        coord1 = 'MULTIPOLYGON(((82.91699 55.042136, 82.917522 55.040187, 82.918063 55.040235, 82.917540 55.042184,82.91699 55.042136)), ((82.91599 55.041136, 82.916522 55.039187, 82.917063 55.039235, 82.916540 55.041184,82.91599 55.041136)))',
                        coord2 = 'MULTILINESTRING((82.91799 55.043136, 82.918522 55.041187, 82.919063 55.041235), (82.91899 55.044136, 82.919522 55.042187, 82.920063 55.042235))',
                        coord3 = 'MULTIPOINT(82.914 55.042136, 82.915 55.043136, 82.915 55.042136, 82.914 55.043136)';

                    map = DG.map('map', {
                        center: [55.041836, 82.91699],
                        zoom: 16
                    });

                    DG.Wkt.geoJsonLayer(coord1).addTo(map);

                    DG.Wkt.geoJsonLayer(coord2).addTo(map);

                    DG.Wkt.geoJsonLayer(coord3).addTo(map);
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/en/manual/base-classes.md
================================================
## Base Classes

{toc}

### DG.Class

<code>DG.Class</code> powers the OOP facilities of maps API and is used to create almost all of the classes documented here.

In addition to implementing a simple classical inheritance model, it introduces several special properties for
convenient code organization — <code>options</code>, <code>includes</code> and <code>statics</code>.

    var MyClass = DG.Class.extend({
        initialize: function (greeter) {
            this.greeter = greeter;
            // class constructor
        },

        greet: function (name) {
            alert(this.greeter + ', ' + name)
        }
    });

    // create instance of MyClass, passing "Hello" to the constructor
    var a = new MyClass("Hello");

    // call greet method, alerting "Hello, World"
    a.greet("World");

#### Class Factories

You may have noticed that maps API objects are created without using the <code>new</code> keyword. This is
achieved by complementing each class with a lowercase factory method:

    new DG.Map('map');  // becomes:
    DG.map('map');

The factories are implemented very easily, and you can do this for your own classes:

    DG.map = function (id, options) {
        return new DG.Map(id, options);
    };

#### Inheritance

You use DG.Class.extend to define new classes, but you can use the same method on any class to inherit from it:

    var MyChildClass = MyClass.extend({
        // ... new properties and methods
    });

This will create a class that inherits all methods and properties of the parent class (through a proper
prototype chain), adding or overriding the ones you pass to extend. It will also properly react to <code>instanceof</code>:

    var a = new MyChildClass();
    a instanceof MyChildClass; // true
    a instanceof MyClass; // true

You can call parent methods (including constructor) from corresponding child ones (as you do with super
calls in other languages) by accessing parent class prototype and using JavaScript's <code>call</code> or <code>apply</code>:

    var MyChildClass = MyClass.extend({
        initialize: function () {
            MyClass.prototype.initialize.call("Yo");
        },

        greet: function (name) {
            MyClass.prototype.greet.call(this, 'bro ' + name + '!');
        }
    });

    var a = new MyChildClass();
    a.greet('Jason'); // alerts "Yo, bro Jason!"

#### Options

<code>options</code> is a special property that unlike other objects that you pass to <code>extend</code>
will be merged with the parent one instead of overriding it completely, which makes managing configuration
of objects and default values convenient:

    var MyClass = DG.Class.extend({
        options: {
            myOption1: 'foo',
            myOption2: 'bar'
        }
    });

    var MyChildClass = DG.Class.extend({
        options: {
            myOption1: 'baz',
            myOption3: 5
        }
    });

    var a = new MyChildClass();
    a.options.myOption1; // 'baz'
    a.options.myOption2; // 'bar'
    a.options.myOption3; // 5

There&#39;s also <a href="/doc/maps/en/manual/utils#util-setoptions"><code>DG.Util.setOptions</code></a>,
a method for conveniently merging options passed to constructor with the defaults defines in the class:

    var MyClass = DG.Class.extend({
        options: {
            foo: 'bar',
            bla: 5
        },

        initialize: function (options) {
            DG.Util.setOptions(this, options);
            ...
        }
    });

    var a = new MyClass({bla: 10});
    a.options; // {foo: 'bar', bla: 10}

#### Includes

<code>includes</code> is a special class property that merges all specified objects into the class
(such objects are called mixins).

     var MyMixin = {
        foo: function () { ... },
        bar: 5
    };

    var MyClass = DG.Class.extend({
        includes: MyMixin
    });

    var a = new MyClass();
    a.foo();

You can also do such includes in runtime with the <code>include</code> method:

    MyClass.include(MyMixin);

#### Statics

<code>statics</code> is just a convenience property that injects specified object properties as the static
properties of the class, useful for defining constants:

    var MyClass = DG.Class.extend({
        statics: {
            FOO: 'bar',
            BLA: 5
        }
    });

    MyClass.FOO; // 'bar'

#### Constructor hooks

If you&#39;re a plugin developer, you often need to add additional initialization code to existing
classes (e.g. editing hooks for <a href="/doc/maps/en/manual/geometries#polyline"><code>DG.Polyline</code></a>).
Maps API comes with a way to do it easily using the <code>addInitHook</code> method:

    MyClass.addInitHook(function () {
        // ... do something in constructor additionally
        // e.g. add event listeners, set custom properties etc.
    });

You can also use the following shortcut when you just need to make one additional method call:

    MyClass.addInitHook('methodName', arg1, arg2, …);

#### Functions

<table>
    <thead>
        <tr>
            <th>Function</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="class-extend">
            <td><code><b>extend</b>(
                <nobr>&lt;Object&gt; <i>props</i> )</nobr>
            </code></td>

            <td><code>Function</code></td>
            <td><a href="#inheritance">Extends the current class</a> given the properties to be included.
                Returns a Javascript function that is a class constructor (to be called with <code>new</code>).</td>
        </tr>
        <tr id="class-include">
            <td><code><b>include</b>(
                <nobr>&lt;Object&gt; <i>properties</i> )</nobr>
            </code></td>

            <td><code></code></td>
            <td><a href="#includes">Includes a mixin</a> into the current class.</td>
        </tr>
        <tr id="class-mergeoptions">
            <td><code><b>mergeOptions</b>(
                <nobr>&lt;Object&gt; <i>options</i> )</nobr>
            </code></td>

            <td><code></code></td>
            <td><a href="#options">Merges <code>options</code></a> into the defaults of the class.</td>
        </tr>
        <tr id="class-addinithook">
            <td><code><b>addInitHook</b>(
                <nobr>&lt;Function&gt; <i>fn</i> )</nobr>
            </code></td>

            <td><code></code></td>
            <td>Adds a <a href="#constructor-hooks">constructor hook</a> to the class.</td>
        </tr>
    </tbody>
</table>

### DG.Evented

A set of methods shared between event-powered classes (like <a href="/doc/maps/en/manual/map#dgmap"><code>Map</code></a>
and <a href="/doc/maps/en/manual/markers#dgmarker"><code>Marker</code></a>). Generally, events allow you
to execute some function when something happens with an object (e.g. the user clicks on the map, causing
the map to fire <code>&#39;click&#39;</code> event).

    map.on('click', function(e) {
        alert(e.latlng);
    } );

Maps API deals with event listeners by reference, so if you want to add a listener and then remove it,
define it as a function:

    function onClick(e) { ... }
    map.on('click', onClick);
    map.off('click', onClick);

#### Methods

<table id="dgevented-methods">
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="evented-on">
            <td><code><b>on</b>(
                <nobr>&lt;String&gt; <i>type</i>,
                <nobr>&lt;Function&gt; <i>fn</i>,
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Adds a listener function (<code>fn</code>) to a particular event type of the object.
                You can optionally specify the context of the listener (object the this keyword will point to).
                You can also pass several space-separated types (e.g. <code>&#39;click dblclick&#39;</code>).</td>
        </tr>
        <tr>
            <td><code><b>on</b>(
                <nobr>&lt;Object&gt; <i>eventMap</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Adds a set of type/listener pairs, e.g. <code>{click: onClick, mousemove: onMouseMove}</code></td>
        </tr>
        <tr id="evented-off">
            <td><code><b>off</b>(
                <nobr>&lt;String&gt; <i>type</i>,
                <nobr>&lt;Function&gt; <i>fn?</i>,
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Removes a previously added listener function. If no function is specified, it will remove all
                the listeners of that particular event from the object. Note that if you passed a custom context
                to <code>on</code>, you must pass the same context to <code>off</code> in order to remove
                the listener.</td>
        </tr>
        <tr>
            <td><code><b>off</b>(
                <nobr>&lt;Object&gt; <i>eventMap</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Removes a set of type/listener pairs.</td>
        </tr>
        <tr>
            <td><code><b>off</b>()</code></td>

            <td><code>this</code></td>
            <td>Removes all listeners to all events on the object.</td>
        </tr>
        <tr id="evented-fire">
            <td><code><b>fire</b>(
                <nobr>&lt;String&gt; <i>type</i>,
                <nobr>&lt;Object&gt; <i>data?</i>,
                <nobr>&lt;Boolean&gt; <i>propagate?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Fires an event of the specified type. You can optionally provide an data object — the first
                argument of the listener function will contain its properties. The event might can optionally
                be propagated to event parents.</td>
        </tr>
        <tr id="evented-listens">
            <td><code><b>listens</b>(
                <nobr>&lt;String&gt; <i>type</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if a particular event type has any listeners attached to it.</td>
        </tr>
        <tr id="evented-once">
            <td><code><b>once</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Behaves as <a href="#evented-on"><code>on(…)</code></a>, except the listener will only get
                fired once and then removed.</td>
        </tr>
        <tr id="evented-addeventparent">
            <td><code><b>addEventParent</b>(
                <nobr>&lt;<a href="#dgevented">Evented</a>&gt; <i>obj</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Adds an event parent - an <a href="#dgevented"><code>Evented</code></a> that will receive
                propagated events</td>
        </tr>
        <tr id="evented-removeeventparent">
            <td><code><b>removeEventParent</b>(
                <nobr>&lt;<a href="#dgevented">Evented</a>&gt; <i>obj</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Removes an event parent, so it will stop receiving propagated events</td>
        </tr>
        <tr id="evented-addeventlistener">
            <td><code><b>addEventListener</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Alias to <a href="#evented-on"><code>on(…)</code></a></td>
        </tr>
        <tr id="evented-removeeventlistener">
            <td><code><b>removeEventListener</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Alias to <a href="#evented-off"><code>off(…)</code></a></td>
        </tr>
        <tr id="evented-clearalleventlisteners">
            <td><code><b>clearAllEventListeners</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Alias to <a href="#evented-off"><code>off()</code></a></td>
        </tr>
        <tr id="evented-addonetimeeventlistener">
            <td><code><b>addOneTimeEventListener</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Alias to <a href="#evented-once"><code>once(…)</code></a></td>
        </tr>
        <tr id="evented-fireevent">
            <td><code><b>fireEvent</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Alias to <a href="#evented-fire"><code>fire(…)</code></a></td>
        </tr>
        <tr id="evented-haseventlisteners">
            <td><code><b>hasEventListeners</b>(<i>…</i>)</code></td>

            <td><code>Boolean</code></td>
            <td>Alias to <a href="#evented-listens"><code>listens(…)</code></a></td>
        </tr>
    </tbody>
</table>

### DG.Layer

A set of methods from the Layer base class that all maps API layers use. Inherits all methods,
options and events from <a href="#dgevented"><code>DG.Evented</code></a>.

    var layer = DG.Marker(latlng).addTo(map);
    layer.addTo(map);
    layer.remove();

#### Options

<table id="dglayer-options">
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layer-pane">
            <td><code><b>pane</b></code></td>
            <td><code>String</code></td>
            <td><code>&#x27;overlayPane&#x27;</code></td>
            <td>By default the layer will be added to the map&#39;s <a href="/doc/maps/en/manual/map#map-overlaypane">overlay pane</a>.
                Overriding this option will cause the layer to be placed on another pane by default.</td>
        </tr>
    </tbody>
</table>

#### Events

<table id="dglayer-events">
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="layer-add">
            <td><code><b>add</b></code></td>
            <td><code><a href="#event-objects">Event</a></code></td>
            <td>Fired after the layer is added to a map</td>
        </tr>
        <tr id="layer-remove">
            <td><code><b>remove</b></code></td>
            <td><code><a href="#event-objects">Event</a></code></td>
            <td>Fired after the layer is removed from a map</td>
        </tr>
    </tbody>
</table>

##### Popup events

<table id="dglayer-popup-events">
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layer-popupopen">
            <td><code><b>popupopen</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Fired when a popup bound to this layer is opened</td>
        </tr>
        <tr id="layer-popupclose">
            <td><code><b>popupclose</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Fired when a popup bound to this layer is closed</td>
        </tr>
    </tbody>
</table>

#### Methods

Classes extending <a href="#dglayer"><code>DG.Layer</code></a> will inherit the following methods:

<table id="dglayer-methods">
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layer-addto">
            <td><code><b>addTo</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/map#dgmap">Map</a>&gt; <i>map</i>)</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Adds the layer to the given map</td>
        </tr>
        <tr id="layer-remove">
            <td><code><b>remove</b>()</code></td>

            <td><code>this</code></td>
            <td>Removes the layer from the map it is currently active on.</td>
        </tr>
        <tr id="layer-removefrom">
            <td><code><b>removeFrom</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Removes the layer from the given map</td>
        </tr>
        <tr id="layer-getpane">
            <td><code><b>getPane</b>(
                <nobr>&lt;String&gt; <i>name?</i> )</nobr>
            </code></td>

            <td><code>HTMLElement</code></td>
            <td>Returns the <code>HTMLElement</code> representing the named pane on the map.
                If <code>name</code> is omitted, returns the pane for this layer.</td>
        </tr>
    </tbody>
</table>

##### Popup methods

All layers share a set of methods convenient for binding popups to it.

    var layer = DG.Polygon(latlngs).bindPopup('Hi There!').addTo(map);
    layer.openPopup();
    layer.closePopup();

Popups will also be automatically opened when the layer is clicked on and closed when the layer
is removed from the map or another popup is opened.

<table id="dglayer-popup-methods">
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layer-bindpopup">
            <td><code><b>bindPopup</b>(
                <nobr>&lt;String|HTMLElement|Function|Popup&gt; <i>content</i>,</nobr>
                <nobr>&lt;<a href="/doc/maps/en/manual/popup#popup-option">Popup options</a>&gt; <i>options?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Binds a popup to the layer with the passed <code>content</code> and sets up the
                neccessary event listeners. If a <code>Function</code> is passed it will receive
                the layer as the first argument and should return a <code>String</code> or <code>HTMLElement</code>.</td>
        </tr>
        <tr id="layer-unbindpopup">
            <td><code><b>unbindPopup</b>()</code></td>

            <td><code>this</code></td>
            <td>Removes the popup previously bound with <code>bindPopup</code>.</td>
        </tr>
        <tr id="layer-openpopup">
            <td><code><b>openPopup</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Opens the bound popup at the specificed <a href="/doc/maps/en/manual/basic-types#dglatlng"><code>latlng</code></a>
                or at the default popup anchor if no <code>latlng</code> is passed.</td>
        </tr>
        <tr id="layer-closepopup">
            <td><code><b>closePopup</b>()</code></td>

            <td><code>this</code></td>
            <td>Closes the popup bound to this layer if it is open.
                Opens or closes the popup bound to this layer depending on its current state.
                Returns <code>true</code> if the popup bound to this layer is currently open.</td>
        </tr>
        <tr id="layer-setpopupcontent">
            <td><code><b>setPopupContent</b>(
            <nobr>&lt;String|HTMLElement|Popup&gt; <i>content</i>,</nobr>
                <nobr>&lt;<a href="/doc/maps/en/manual/popup#popup-option">Popup options</a>&gt; <i>options?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Sets the content of the popup bound to this layer.</td>
        </tr>
        <tr id="layer-getpopup">
            <td><code><b>getPopup</b>()</code></td>

            <td><code><a href="/doc/maps/en/manual/popup#dgpopup">Popup</a></code></td>
            <td>Returns the popup bound to this layer.</td>
        </tr>
    </tbody>
</table>

##### Extension methods

Every layer should extend from <a href="#dglayer"><code>DG.Layer</code></a> and (re-)implement the following methods.

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layer-onadd">
            <td><code><b>onAdd</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Should contain code that creates DOM elements for the layer, adds them to <code>map panes</code>
                where they should belong and puts listeners on relevant map events. Called on
                <a href="/doc/maps/en/manual/map#map-addlayer"><code>map.addLayer(layer)</code></a>.</td>
        </tr>
        <tr id="layer-onremove">
            <td><code><b>onRemove</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Should contain all clean up code that removes the layer&#39;s elements from the DOM and removes
                listeners previously added in <a href="#layer-onadd"><code>onAdd</code></a>.
                Called on <a href="/doc/maps/en/manual/map#map-removelayer"><code>map.removeLayer(layer)</code></a>.</td>
        </tr>
        <tr id="layer-getevents">
            <td><code><b>getEvents</b>()</code></td>

            <td><code>Object</code></td>
            <td>This optional method should return an object like <code>{ viewreset: this._reset }</code>
                for <a href="#evented-addeventlistener"><code>addEventListener</code></a>.
                These events will be automatically added and removed from the map with your layer.</td>
        </tr>
        <tr id="layer-beforeadd">
            <td><code><b>beforeAdd</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Optional method. Called on <a href="/doc/maps/en/manual/map#map-addlayer"><code>map.addLayer(layer)</code></a>,
                before the layer is added to the map, before events are initialized, without waiting until
                the map is in a usable state. Use for early initialization only.</td>
        </tr>
    </tbody>
</table>

Events inherited from <a href="#dgevented">Evented</a> <!-- TODO: include events -->

### DG.Control

DG.Control is a base class for implementing map controls. Handles positioning. All other controls extend from this class.

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-position">
            <td><code><b>position</b></code></td>
            <td><code>String</code></code></td>
            <td><code>&#x27;topright&#x27;</code></td>
            <td>The position of the control (one of the map corners). Possible values are <code>&#39;topleft&#39;</code>,
                <code>&#39;topright&#39;</code>, <code>&#39;bottomleft&#39;</code> or <code>&#39;bottomright&#39;</code></td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-getposition">
            <td><code><b>getPosition</b>()</code></td>

            <td><code>string</code></td>
            <td>Returns the position of the control.</td>
        </tr>
        <tr id="control-setposition">
            <td><code><b>setPosition</b>(
                <nobr>&lt;string&gt; <i>position</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Sets the position of the control.</td>
        </tr>
        <tr id="control-getcontainer">
            <td><code><b>getContainer</b>()</code></td>

            <td><code>HTMLElement</code></td>
            <td>Returns the HTMLElement that contains the control.</td>
        </tr>
        <tr id="control-addto">
            <td><code><b>addTo</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Adds the control to the given map.</td>
        </tr>
        <tr id="control-remove">
            <td><code><b>remove</b>()</code></td>

            <td><code>this</code></td>
            <td>Removes the control from the map it is currently active on.</td>
        </tr>
    </tbody>
</table>

### DG.Handler

Abstract class for map interaction handlers.

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="handler-enable">
            <td><code><b>enable</b>()</code></td>

            <td><code></code></td>
            <td>Enables the handler</td>
        </tr>
        <tr id="handler-disable">
            <td><code><b>disable</b>()</code></td>

            <td><code></code></td>
            <td>Disables the handler</td>
        </tr>
        <tr id="handler-enabled">
            <td><code><b>enabled</b>()</code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the handler is enabled</td>
        </tr>
    </tbody>
</table>

#### Extension methods

Classes inheriting from <a href="#dghandler"><code>Handler</code></a> must implement the two following methods:

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="handler-addhooks">
            <td><code><b>addHooks</b>()</code></td>

            <td><code></code></td>
            <td>Called when the handler is enabled, should add event hooks.</td>
        </tr>
        <tr id="handler-removehooks">
            <td><code><b>removeHooks</b>()</code></td>

            <td><code></code></td>
            <td>Called when the handler is disabled, should remove the event hooks added previously.</td>
        </tr>
    </tbody>
</table>

### DG.Projection

An object with methods for projecting geographical coordinates of the world onto a flat surface (and back).
See <a href="http://en.wikipedia.org/wiki/Map_projection">Map projection</a>.

Maps API uses a Spherical Mercator projection. Assumes that Earth is a sphere.

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="projection-project">
            <td><code><b>project</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Projects geographical coordinates into a 2D point.</td>
        </tr>
        <tr id="projection-unproject">
            <td><code><b>unproject</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>The inverse of <code>project</code>. Projects a 2D point into a geographical location.</td>
        </tr>
    </tbody>
</table>

#### Properties

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="projection-bounds">
            <td><code><b>bounds</b></code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#latlngbounds">LatLngBounds</a></code></td>
            <td>The bounds where the projection is valid</td>
        </tr>
    </tbody>
</table>

### DG.Renderer

Base class for vector renderer implementations (<code>DG.SVG</code>, <code>DG.Canvas</code>). Handles the
DOM container of the renderer, its bounds, and its zoom animation. A <a href="#dgrenderer"><code>Renderer</code></a>
works as an implicit layer group for all <a href="/doc/maps/en/manual/vector-layers#dgpath"><code>DG.Path</code></a>s
- the renderer itself can be added or removed to the map. All paths use a renderer, which can
be implicit (the map will decide the type of renderer and use it automatically) or explicit
(using the <a href="/doc/maps/en/manual/vector-layers#path-renderer"><code>renderer</code></a> option of the path).
Do not use this class directly, use <code>DG.SVG</code> and <code>DG.Canvas</code> instead.

##### Options

<table id="dgrenderer-options">
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
        </thead><tbody>
        <tr id="renderer-padding">
            <td><code><b>padding</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.1</code></td>
            <td>How much to extend the clip area around the map view (relative to its size)
                e.g. 0.1 would be 10% of map view in each direction</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="#dglayer">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="#dglayer">Layer</a> <!-- TODO: include events -->

#### Methods

Methods inherited from <a href="#dglayer">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="#dgevented">Evented</a> <!-- TODO: include methods -->

### Event objects

Whenever a class inheriting from <a href="#dgevented"><code>Evented</code></a> fires an event, a listener function
will be called with an event argument, which is a plain object containing information about the event. For example:

    map.on('click', function(ev) {
        alert(ev.latlng); // ev is an event object (MouseEvent in this case)
    });

The information available depends on the event type:

#### Event

The base event object. All other event objects contain these properties too.

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="event-type">
            <td><code><b>type</b></code></td>
            <td><code>String</code></td>
            <td>The event type (e.g. <code>&#39;click&#39;</code>).</td>
        </tr>
        <tr id="event-target">
            <td><code><b>target</b></code></td>
            <td><code>Object</code></td>
            <td>The object that fired the event.</td>
        </tr>
    </tbody>
</table>

#### MouseEvent

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="mouseevent-latlng">
            <td><code><b>latlng</b></code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#latlng">LatLng</a></code></td>
            <td>The geographical point where the mouse event occured.</td>
        </tr>
        <tr id="mouseevent-layerpoint">
            <td><code><b>layerPoint</b></code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Pixel coordinates of the point where the mouse event occured relative to the map layer.</td>
        </tr>
        <tr id="mouseevent-containerpoint">
            <td><code><b>containerPoint</b></code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Pixel coordinates of the point where the mouse event occured relative to the map сontainer.</td>
        </tr>
        <tr id="mouseevent-originalevent">
            <td><code><b>originalEvent</b></code></td>
            <td><code>DOMMouseEvent</code></td>
            <td>The original DOM mouse event fired by the browser.</td>
        </tr>
    </tbody>
</table>

Properties inherited from <a href="#event">Event</a> <!-- TODO: include properties -->

#### LocationEvent

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="locationevent-latlng">
            <td><code><b>latlng</b></code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#latlng">LatLng</a></code></td>
            <td>Detected geographical location of the user.</td>
        </tr>
        <tr id="locationevent-bounds">
            <td><code><b>bounds</b></code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#latlngbounds">LatLngBounds</a></code></td>
            <td>Geographical bounds of the area user is located in (with respect to the accuracy of location).</td>
        </tr>
        <tr id="locationevent-accuracy">
            <td><code><b>accuracy</b></code></td>
            <td><code>Number</code></td>
            <td>Accuracy of location in meters.</td>
        </tr>
        <tr id="locationevent-altitude">
            <td><code><b>altitude</b></code></td>
            <td><code>Number</code></td>
            <td>Height of the position above the WGS84 ellipsoid in meters.</td>
        </tr>
        <tr id="locationevent-altitudeaccuracy">
            <td><code><b>altitudeAccuracy</b></code></td>
            <td><code>Number</code></td>
            <td>Accuracy of altitude in meters.</td>
        </tr>
        <tr id="locationevent-heading">
            <td><code><b>heading</b></code></td>
            <td><code>Number</code></td>
            <td>The direction of travel in degrees counting clockwise from true North.</td>
        </tr>
        <tr id="locationevent-speed">
            <td><code><b>speed</b></code></td>
            <td><code>Number</code></td>
            <td>Current velocity in meters per second.</td>
        </tr>
        <tr id="locationevent-timestamp">
            <td><code><b>timestamp</b></code></td>
            <td><code>Number</code></td>
            <td>The time when the position was acquired.</td>
        </tr>
    </tbody>
</table>

Properties inherited from <a href="#event">Event</a> <!-- TODO: include properties -->

#### ErrorEvent

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="errorevent-message">
            <td><code><b>message</b></code></td>
            <td><code>String</code></td>
            <td>Error message.</td>
        </tr>
        <tr id="errorevent-code">
            <td><code><b>code</b></code></td>
            <td><code>Number</code></td>
            <td>Error code (if applicable).</td>
        </tr>
    </tbody>
</table>

Properties inherited from <a href="#event">Event</a> <!-- TODO: include properties -->

#### LayerEvent

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layerevent-layer">
            <td><code><b>layer</b></code></td>
            <td><code><a href="#dglayer">ILayer</a></code></td>
            <td>The layer that was added or removed.</td>
        </tr>
    </tbody>
</table>

Properties inherited from <a href="#event">Event</a> <!-- TODO: include properties -->

#### LayersControlEvent

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layerscontrolevent-layer">
            <td><code><b>layer</b></code></td>
            <td><code><a href="#dglayer">ILayer</a></code></td>
            <td>The layer that was added or removed.</td>
        </tr>
        <tr id="layerscontrolevent-name">
            <td><code><b>name</b></code></td>
            <td><code>String</code></td>
            <td>The name of the layer that was added or removed.</td>
        </tr>
    </tbody>
</table>

Properties inherited from <a href="#event">Event</a> <!-- TODO: include properties -->

#### TileEvent

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
	</thead>
	<tbody>
        <tr id="tileevent-tile">
            <td><code><b>tile</b></code></td>
            <td><code>HTMLElement</code></td>
            <td>The tile element (image).</td>
        </tr>
    </tbody>
</table>

Properties inherited from <a href="#event">Event</a> <!-- TODO: include properties -->

#### TileErrorEvent

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="tileerrorevent-tile">
            <td><code><b>tile</b></code></td>
            <td><code>HTMLElement</code></td>
            <td>The tile element (image).</td>
        </tr>
    </tbody>
</table>

Properties inherited from <a href="#event">Event</a> <!-- TODO: include properties -->

#### ResizeEvent

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="resizeevent-oldsize">
            <td><code><b>oldSize</b></code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>The old size before resize event.</td>
        </tr>
        <tr id="resizeevent-newsize">
            <td><code><b>newSize</b></code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>The new size after the resize event.</td>
        </tr>
    </tbody>
</table>

Properties inherited from <a href="#event">Event</a> <!-- TODO: include properties -->

#### GeoJSON event

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
        </thead><tbody>
        <tr id="geojson-event-layer">
            <td><code><b>layer</b></code></td>
            <td><code><a href="#dglayer">ILayer</a></code></td>
            <td>The layer for the GeoJSON feature that is being added to the map.</td>
        </tr>
        <tr id="geojson-event-properties">
            <td><code><b>properties</b></code></td>
            <td><code>Object</code></td>
            <td>GeoJSON properties of the feature.</td>
        </tr>
        <tr id="geojson-event-geometrytype">
            <td><code><b>geometryType</b></code></td>
            <td><code>String</code></td>
            <td>GeoJSON geometry type of the feature.</td>
        </tr>
        <tr id="geojson-event-id">
            <td><code><b>id</b></code></td>
            <td><code>String</code></td>
            <td>GeoJSON ID of the feature (if present).</td>
        </tr>
    </tbody>
</table>

Properties inherited from <a href="#event">Event</a> <!-- TODO: include properties -->

#### Popup event

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
        </thead><tbody>
        <tr id="popup-event-popup">
            <td><code><b>popup</b></code></td>
            <td><code><a href="/doc/maps/en/manual/popup#dgpopup">Popup</a></code></td>
            <td>The popup that was opened or closed.</td>
        </tr>
    </tbody>
</table>

Properties inherited from <a href="#event">Event</a> <!-- TODO: include properties -->

#### DragEndEvent

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="dragendevent-distance">
            <td><code><b>distance</b></code></td>
            <td><code>Number</code></td>
            <td>The distance in pixels the draggable element was moved by.</td>
        </tr>
    </tbody>
</table>

#### MetaEvent

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>latlng</b></code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>The geographical coordinates of the metalayer's point.</td>
        </tr>
        <tr>
            <td><code><b>meta</b></code></td>
            <td><code>Object</code></td>
            <td>Metalayer's data.</td>
        </tr>
    </tbody>
</table>

#### LangEvent

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>lang</b></code></td>
            <td><code>String</code></td>
            <td>The current map's language.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/en/manual/basic-types.md
================================================
## Basic Types

This section describes the classes of basic data types that are often found in the pages of maps API guide and
required for use with many maps API objects.

{toc}

### DG.LatLng

Represents a geographical point with a certain latitude and longitude.

    var latlng = DG.latLng(54.98, 82.89);

All methods that accept LatLng objects also accept them in a simple Array form and simple object form
(unless noted otherwise), so these lines are equivalent:

    map.panTo([54.98, 82.89]);
    map.panTo({lon: 82.89, lat: 54.98});
    map.panTo({lat: 54.98, lng: 82.89});
    map.panTo(DG.latLng(54.98, 82.89));

#### Constructor

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
		</tr>
    </thead>
    <tbody>
        <tr id="latlng-l-latlng">
            <td><code><b>DG.latLng</b>(
                <nobr>&lt;Number&gt; <i>latitude</i>,</nobr>
                <nobr>&lt;Number&gt; <i>longitude</i>,</nobr>
                <nobr>&lt;Number&gt; <i>altitude?</i> )</nobr>
            </code></td>
            <td>Creates an object representing a geographical point with the given latitude and longitude
                (and optionally altitude).</td>
        </tr>
        <tr>
            <td><code><b>DG.latLng</b>(
                <nobr>&lt;Array&gt; <i>coords</i> )</nobr>
            </code></td>
            <td>Expects an array of the form <code>[Number, Number]</code> or <code>[Number, Number, Number]</code>
                instead.</td>
        </tr>
        <tr>
            <td><code><b>DG.latLng</b>(
                <nobr>&lt;Object&gt; <i>coords</i> )</nobr>
            </code></td>
            <td>Expects an plain object of the form <code>{lat: Number, lng: Number}</code> or
                <code>{lat: Number, lng: Number, alt: Number}</code> instead.</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="latlng-equals">
            <td><code><b>equals</b>(
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>otherLatLng</i>,</nobr>
                <nobr>&lt;Number&gt; <i>maxMargin?</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the given <a href="#dglatlng"><code>LatLng</code></a> point is at the
                same position (within a small margin of error). The margin of error can be overriden by setting
                <code>maxMargin</code> to a small number.</td>
        </tr>
        <tr id="latlng-tostring">
            <td><code><b>toString</b>()</code></td>

            <td><code>String</code></td>
            <td>Returns a string representation of the point (for debugging purposes).</td>
        </tr>
        <tr id="latlng-distanceto">
            <td><code><b>distanceTo</b>(
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>otherLatLng</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Returns the distance (in meters) to the given <a href="#dglatlng"><code>LatLng</code></a>
                calculated using the <a href="http://en.wikipedia.org/wiki/Haversine_formula">Haversine formula</a>.</td>
        </tr>
        <tr id="latlng-wrap">
            <td><code><b>wrap</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td>Returns a new <a href="#dglatlng"><code>LatLng</code></a> object with the longitude wrapped
                so it&#39;s always between -180 and +180 degrees.</td>
        </tr>
        <tr id="latlng-tobounds">
            <td><code><b>toBounds</b>(
                <nobr>&lt;Number&gt; <i>sizeInMeters</i> )</nobr>
            </code></td>

            <td><code><a href="#dglatlngbounds">LatLngBounds</a></code></td>
            <td>Returns a new <a href="#dglatlngbounds"><code>LatLngBounds</code></a> object in which each boundary
                is <code>sizeInMeters</code> meters apart from the <a href="#dglatlng"><code>LatLng</code></a>.</td>
        </tr>
    </tbody>
</table>

#### Properties

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="latlng-lat">
            <td><code><b>lat</b></code></td>
            <td><code>Number</code></td>
            <td>Latitude in degrees.</td>
        </tr>
        <tr id="latlng-lng">
            <td><code><b>lng</b></code></td>
            <td><code>Number</code></td>
            <td>Longitude in degrees.</td>
        </tr>
        <tr id="latlng-alt">
            <td><code><b>alt</b></code></td>
            <td><code>Number</code></td>
            <td>Altitude in meters (optional).</td>
        </tr>
    </tbody>
</table>

### DG.LatLngBounds

Represents a rectangular geographical area on a map.

    var southWest = DG.latLng(54.9801, 82.8974),
        northEast = DG.latLng(54.9901, 82.9074),
        bounds = DG.latLngBounds(southWest, northEast);

All methods that accept LatLngBounds objects also accept them in a simple Array form (unless noted otherwise),
so the bounds example above can be passed like this:

    map.fitBounds([
        [54.9801, 82.8974],
        [54.9901, 82.9074]
    ]);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="latlngbounds-l-latlngbounds">
            <td><code><b>DG.latLngBounds</b>(
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>southWest</i>,</nobr>
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>northEast</i> )</nobr>
            </code></td>
            <td>Creates a <a href="#dglatlngbounds"><code>LatLngBounds</code></a> object by defining south-west
                and north-east corners of the rectangle.</td>
        </tr>
        <tr>
            <td><code><b>DG.latLngBounds</b>(
                <nobr>&lt;LatLng[]&gt; <i>latlngs</i>)</nobr>
            </code></td>
            <td>Creates a <a href="#dglatlngbounds"><code>LatLngBounds</code></a> object defined by the geographical
                points it contains. Very useful for zooming the map to fit a particular set of locations with
                <a href="/doc/maps/en/manual/map#map-fitbounds">fitBounds</a>.</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="latlngbounds-extend">
            <td><code><b>extend</b>(
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Extend the bounds to contain the given point.</td>
        </tr>
        <tr>
            <td><code><b>extend</b>(
                <nobr>&lt;<a href="#dglatlngbounds">LatLngBounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Extend the bounds to contain the given bounds.</td>
        </tr>
        <tr id="latlngbounds-pad">
            <td><code><b>pad</b>(
                <nobr>&lt;Number&gt; <i>bufferRatio</i> )</nobr>
            </code></td>

            <td><code><a href="#dglatlngbounds">LatLngBounds</a></code></td>
            <td>Returns bigger bounds created by extending the current bounds by a given percentage in each direction.</td>
        </tr>
        <tr id="latlngbounds-getcenter">
            <td><code><b>getCenter</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td>Returns the center point of the bounds.</td>
        </tr>
        <tr id="latlngbounds-getsouthwest">
            <td><code><b>getSouthWest</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td>Returns the south-west point of the bounds.</td>
        </tr>
        <tr id="latlngbounds-getnortheast">
            <td><code><b>getNorthEast</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td>Returns the north-east point of the bounds.</td>
        </tr>
        <tr id="latlngbounds-getnorthwest">
            <td><code><b>getNorthWest</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td>Returns the north-west point of the bounds.</td>
        </tr>
        <tr id="latlngbounds-getsoutheast">
            <td><code><b>getSouthEast</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td>Returns the south-east point of the bounds.</td>
        </tr>
        <tr id="latlngbounds-getwest">
            <td><code><b>getWest</b>()</code></td>

            <td><code>Number</code></td>
            <td>Returns the west longitude of the bounds.</td>
        </tr>
        <tr id="latlngbounds-getsouth">
            <td><code><b>getSouth</b>()</code></td>

            <td><code>Number</code></td>
            <td>Returns the south latitude of the bounds.</td>
        </tr>
        <tr id="latlngbounds-geteast">
            <td><code><b>getEast</b>()</code></td>

            <td><code>Number</code></td>
            <td>Returns the east longitude of the bounds.</td>
        </tr>
        <tr id="latlngbounds-getnorth">
            <td><code><b>getNorth</b>()</code></td>

            <td><code>Number</code></td>
            <td>Returns the north latitude of the bounds.</td>
        </tr>
        <tr id="latlngbounds-contains">
            <td><code><b>contains</b>(
                <nobr>&lt;<a href="#dglatlngbounds">LatLngBounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the rectangle contains the given one.</td>
        </tr>
        <tr id="latlngbounds-contains">
            <td><code><b>contains</b>(
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
             </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the rectangle contains the given point.</td>
        </tr>
        <tr id="latlngbounds-intersects">
            <td><code><b>intersects</b>(
                <nobr>&lt;<a href="#dglatlngbounds">LatLngBounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the rectangle intersects the given bounds. Two bounds intersect
                if they have at least one point in common.</td>
        </tr>
        <tr id="latlngbounds-overlaps">
            <td><code><b>overlaps</b>(
                <nobr>&lt;<a href="#dgbounds">Bounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the rectangle overlaps the given bounds. Two bounds overlap
                if their intersection is an area.</td>
        </tr>
        <tr id="latlngbounds-tobboxstring">
            <td><code><b>toBBoxString</b>()</code></td>

            <td><code>String</code></td>
            <td>Returns a string with bounding box coordinates in a
                &#39;southwest_lng,southwest_lat,northeast_lng,northeast_lat&#39; format. Useful for sending
                requests to web services that return geo data.</td>
        </tr>
        <tr id="latlngbounds-equals">
            <td><code><b>equals</b>(
                <nobr>&lt;<a href="#dglatlngbounds">LatLngBounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the rectangle is equivalent (within a small margin of error)
                to the given bounds.</td>
        </tr>
        <tr id="latlngbounds-isvalid">
            <td><code><b>isValid</b>()</code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the bounds are properly initialized.</td>
        </tr>
    </tbody>
</table>

### DG.Point

Represents a point with x and y coordinates in pixels.

    var point = DG.point(200, 300);

All methods and options that accept Point objects also accept them in a simple Array form
(unless noted otherwise), so these lines are equivalent:

    map.panBy([200, 300]);
    map.panBy(DG.point(200, 300));

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="point-l-point">
            <td><code><b>DG.point</b>(
                <nobr>&lt;Number&gt; <i>x</i>,</nobr>
                <nobr>&lt;Number&gt; <i>y</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>round?</i> )</nobr>
            </code></td>
            <td>Creates a Point object with the given <code>x</code> and <code>y</code> coordinates.
                If optional <code>round</code> is set to true, rounds the <code>x</code> and <code>y</code> values.</td>
        </tr>
        <tr id="point-l-point">
            <td><code><b>DG.point</b>(
                <nobr>&lt;Number[]&gt; <i>coords</i>)</nobr>
            </code></td>
            <td>Expects an array of the form <code>[x, y]</code> instead.</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="point-clone">
            <td><code><b>clone</b>()</nobr></code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns a copy of the current point.</td>
        </tr>
        <tr id="point-add">
            <td><code><b>add</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>otherPoint</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns the result of addition of the current and the given points.</td>
        </tr>
        <tr id="point-subtract">
            <td><code><b>subtract</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>otherPoint</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns the result of subtraction of the given point from the current.</td>
        </tr>
        <tr id="point-divideby">
            <td><code><b>divideBy</b>(
                <nobr>&lt;Number&gt; <i>num</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns the result of division of the current point by the given number.</td>
        </tr>
        <tr id="point-multiplyby">
            <td><code><b>multiplyBy</b>(
                <nobr>&lt;Number&gt; <i>num</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns the result of multiplication of the current point by the given number.</td>
        </tr>
        <tr id="point-scaleby">
            <td><code><b>scaleBy</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>scale</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Multiply each coordinate of the current point by each coordinate of
                <code>scale</code>. In linear algebra terms, multiply the point by the
                <a href="https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation">scaling matrix</a>
                defined by <code>scale</code>.</td>
        </tr>
        <tr id="point-unscaleby">
            <td><code><b>unscaleBy</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>scale</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Inverse of <code>scaleBy</code>. Divide each coordinate of the current point by
                each coordinate of <code>scale</code>.</td>
        </tr>
        <tr id="point-round">
            <td><code><b>round</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns a copy of the current point with rounded coordinates.</td>
        </tr>
        <tr id="point-floor">
            <td><code><b>floor</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns a copy of the current point with floored coordinates (rounded down).</td>
        </tr>
        <tr id="point-ceil">
            <td><code><b>ceil</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns a copy of the current point with ceiled coordinates (rounded up).</td>
        </tr>
        <tr id="point-distanceto">
            <td><code><b>distanceTo</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>otherPoint</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Returns the cartesian distance between the current and the given points.</td>
        </tr>
        <tr id="point-equals">
            <td><code><b>equals</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>otherPoint</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the given point has the same coordinates.</td>
        </tr>
        <tr id="point-contains">
            <td><code><b>contains</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>otherPoint</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if both coordinates of the given point are less than
                the corresponding current point coordinates (in absolute values).</td>
        </tr>
        <tr id="point-tostring">
            <td><code><b>toString</b>()</code></td>

            <td><code>String</code></td>
            <td>Returns a string representation of the point for debugging purposes.</td>
        </tr>
    </tbody>
</table>

#### Properties

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>x</b></code></td>
            <td><code>Number</code></td>
            <td><code>x</code> coordinate.</td>
        </tr>
        <tr>
            <td><code><b>y</b></code></td>
            <td><code>Number</code></td>
            <td><code>y</code> coordinate.</td>
        </tr>
    </tbody>
</table>

### DG.Bounds

Represents a rectangular area in pixel coordinates.

    var p1 = DG.point(10, 10),
        p2 = DG.point(40, 60),
        bounds = DG.bounds(p1, p2);

All methods that accept <a href="#dgbounds"><code>Bounds</code></a> objects also accept them in a simple Array form
(unless noted otherwise), so the bounds example above can be passed like this:</p>

    otherBounds.intersects([[10, 10], [40, 60]]);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="bounds-l-bounds">
            <td><code><b>DG.bounds</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>topLeft</i>,</nobr>
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>bottomRight</i> )</nobr>
            </code></td>
            <td>Creates a Bounds object from two coordinates (usually top-left and bottom-right corners).</td>
        </tr>
        <tr id="bounds-l-bounds">
            <td><code><b>DG.bounds</b>(
                <nobr>&lt;Point[]&gt; <i>points</i> )</nobr>
            </code></td>
            <td>Creates a Bounds object from the points it contains.</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="bounds-extend">
            <td><code><b>extend</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>point</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Extends the bounds to contain the given point.</td>
        </tr>
        <tr id="bounds-getcenter">
            <td><code><b>getCenter</b>(
                <nobr>&lt;Boolean&gt; <i>round?</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns the center point of the bounds.</td>
        </tr>
        <tr id="bounds-getbottomleft">
            <td><code><b>getBottomLeft</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns the bottom-left point of the bounds.</td>
        </tr>
        <tr id="bounds-gettopright">
            <td><code><b>getTopRight</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns the top-right point of the bounds.</td>
        </tr>
        <tr id="bounds-getsize">
            <td><code><b>getSize</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Returns the size of the given bounds.</td>
        </tr>
        <tr id="bounds-contains">
            <td><code><b>contains</b>(
                <nobr>&lt;<a href="#dgbounds">Bounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the rectangle contains the given one.</td>
        </tr>
        <tr id="bounds-contains">
            <td><code><b>contains</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>point</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the rectangle contains the given poing.</td>
        </tr>
        <tr id="bounds-intersects">
            <td><code><b>intersects</b>(
                <nobr>&lt;<a href="#dgbounds">Bounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the rectangle intersects the given bounds. Two bounds
                intersect if they have at least one point in common.</td>
        </tr>
        <tr id="bounds-overlaps">
            <td><code><b>overlaps</b>(
                <nobr>&lt;<a href="#dgbounds">Bounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the rectangle overlaps the given bounds. Two bounds
                overlap if their intersection is an area.</td>
        </tr>
    </tbody>
</table>

#### Properties

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="bounds-min">
            <td><code><b>min</b></code></td>
            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>The top left corner of the rectangle.</td>
        </tr>
        <tr id="bounds-max">
            <td><code><b>max</b></code></td>
            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>The bottom right corner of the rectangle.</td>
        </tr>
	</tbody>
</table>


================================================
FILE: src/doc/en/manual/controls.md
================================================
## Controls

Controls is a user interface components by which a user can interact with the map.

{toc}

### DG.Control.Zoom

A basic zoom control with two buttons (zoom in and zoom out). It is put on the map by default unless
you set its <a href="/doc/maps/en/manual/map#map-zoomcontrol"><code>zoomControl</code> option</a> to <code>false</code>.
Extends <a href="/doc/maps/en/manual/base-classes#dgcontrol"><code>Control</code></a>.

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-zoom-l-control-zoom">
            <td><code><b>DG.control.zoom</b>(
                <nobr>&lt;<a href="#control-zoom-option">DG.Control.Zoom options</a>&gt; <i>options</i> )</nobr>
            </code></td>
            <td>Creates a zoom control</td>
	    </tr>
	</tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-zoom-zoomintext">
            <td><code><b>zoomInText</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;+&#x27;</code></td>
            <td>The text set on the &#39;zoom in&#39; button.</td>
        </tr>
        <tr id="control-zoom-zoomintitle">
            <td><code><b>zoomInTitle</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;Zoom in&#x27;</code></td>
            <td>The title set on the &#39;zoom in&#39; button.</td>
        </tr>
        <tr id="control-zoom-zoomouttext">
            <td><code><b>zoomOutText</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;-&#x27;</code></td>
            <td>The text set on the &#39;zoom out&#39; button.</td>
        </tr>
        <tr id="control-zoom-zoomouttitle">
            <td><code><b>zoomOutTitle</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;Zoom out&#x27;</code></td>
            <td>The title set on the &#39;zoom out&#39; button.</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Methods

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.Attribution

The attribution control allows you to display attribution data in a small text box on a map.
It is put on the map by default unless you set its
<a href="/doc/maps/en/manual/map#map-attributioncontrol"><code>attributionControl</code> option</a>
to <code>false</code>, and it fetches attribution texts from layers with the
<a href="/doc/maps/en/manual/base-classes#layer-getattribution"><code>getAttribution</code> method</a> automatically.
Extends <a href="/doc/maps/en/manual/base-classes#dgcontrol"><code>DG.Control</code></a>.

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-attribution-l-control-attribution">
            <td><code><b>DG.control.attribution</b>(
                <nobr>&lt;<a href="#control-attribution-option">DG.Control.Attribution options</a>&gt; <i>options</i> )</nobr>
            </code></td>
            <td>Creates an attribution control.</td>
        </tr>
	</tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-attribution-prefix">
            <td><code><b>prefix</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;Leaflet&#x27;</code></td>
            <td>The HTML text shown before the attributions. Pass <code>false</code> to disable.</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Methods

<table>
    <thead>
	<tr>
		<th>Method</th>
		<th>Returns</th>
		<th>Description</th>
	</tr>
	</thead>
	<tbody>
        <tr id="control-attribution-setprefix">
            <td><code><b>setPrefix</b>(
                <nobr>&lt;String&gt; <i>prefix</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Sets the text before the attributions.</td>
        </tr>
        <tr id="control-attribution-addattribution">
            <td><code><b>addAttribution</b>(
                <nobr>&lt;String&gt; <i>text</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Adds an attribution text (e.g. <code>&#39;Vector data &amp;copy; Mapbox&#39;</code>).</td>
        </tr>
        <tr id="control-attribution-removeattribution">
            <td><code><b>removeAttribution</b>(
                <nobr>&lt;String&gt; <i>text</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Removes an attribution text.</td>
        </tr>
    </tbody>
</table>

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.Scale

A simple scale control that shows the scale of the current center of screen in metric (m/km) and imperial
(mi/ft) systems. Extends <a href="/doc/maps/en/manual/base-classes#dgcontrol"><code>DG.Control</code></a>.

    DG.control.scale().addTo(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-scale-l-control-scale">
            <td><code><b>DG.control.scale</b>(
                <nobr>&lt;<a href="#control-scale-option">DG.Control.Scale options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Creates an scale control with the given options.</td>
        </tr>
	</tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-scale-maxwidth">
            <td><code><b>maxWidth</b></code></td>
            <td><code>Number </code></td>
            <td><code>100</code></td>
            <td>Maximum width of the control in pixels. The width is set dynamically to show round values (e.g. 100, 200, 500).</td>
        </tr>
        <tr id="control-scale-metric">
            <td><code><b>metric</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>True</code></td>
            <td>Whether to show the metric scale line (m/km).</td>
        </tr>
        <tr id="control-scale-imperial">
            <td><code><b>imperial</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>True</code></td>
            <td>Whether to show the imperial scale line (mi/ft).</td>
        </tr>
        <tr id="control-scale-updatewhenidle">
            <td><code><b>updateWhenIdle</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If <code>true</code>, the control is updated on <a href="/doc/maps/en/manual/map#map-moveend"><code>moveend</code></a>,
                otherwise it&#39;s always up-to-date (updated on <a href="/doc/maps/en/manual/map#map-move"><code>move</code></a>).</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Methods

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.Ruler

When clicked opens a ruler - the tool for measurement of distances on a map.
Extends <a href="/doc/maps/en/manual/base-classes#dgcontrol"><code>DG.Control</code></a>.

    DG.control.ruler().addTo(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-ruler-l-control-ruler">
            <td><code><b>DG.control.ruler</b>(
                <nobr>&lt;<a href="#control-ruler-option">DG.Control.Ruler options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Creates a ruler control with the given options.</td>
        </tr>
	</tbody>
</table>

#### Options

Options inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Methods

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.Traffic

The traffic control allows you to display traffic overlay data on a map.
Extends <a href="/doc/maps/en/manual/base-classes#dgcontrol"><code>DG.Control</code></a>.

    DG.control.traffic().addTo(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-traffic-l-control-traffic">
            <td><code><b>DG.control.traffic</b>(
                <nobr>&lt;<a href="#control-traffic-option">DG.Control.Traffic options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Creates a traffic control with the given options.</td>
        </tr>
	</tbody>
</table>

#### Options

Options inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Methods

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.Fullscreen

The fullscreen control enables display of the map over fullscreen window which bounds are physical bounds of a given
user monitor. The button works like a trigger. It is put on the map by default unless you set its
<a href="/doc/maps/en/manual/map#map-attributioncontrol"><code>fullscreenControl</code> option</a> to <code>false</code>.
Extends <a href="/doc/maps/en/manual/base-classes#dgcontrol"><code>DG.Control</code></a>.

    DG.control.fullscreen().addTo(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-fullscreen-l-control-fullscreen">
            <td><code><b>DG.control.fullscreen</b>(
                <nobr>&lt;<a href="#control-fullscreen-option">DG.Control.Fullscreen options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Creates a fullscreen control with the given options.</td>
        </tr>
	</tbody>
</table>

#### Options

Options inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Methods

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.LocationControl

The geo-location control allow users to detect their geographic positions and automatically pan the map layer to found coordinates.
Control is disabled if geo-location API is not available.

    DG.control.location().addTo(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-location-l-control-location">
            <td><code><b>DG.control.location</b>(
                <nobr>&lt;<a href="#control-location-option">DG.Control.LocationControl options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Creates a geo-location control with the given options.</td>
        </tr>
	</tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-location-drawcircle">
            <td><code><b>drawCircle</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Will the circle showing the accuracy of the detection be displayed or not.</td>
        </tr>
        <tr id="control-location-follow">
            <td><code><b>follow</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Update user location dynamically or not, works if <code>watch</code> and <code>setView</code> options are
                exposed to <code>true</code> in <code>locateOptions</code>.</td>
        </tr>
        <tr id="control-location-stopfollowingondrag">
            <td><code><b>stopFollowingOnDrag</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Enables or disables the user's location update as he drag the map.</td>
        </tr>
        <tr id="control-location-metric">
            <td><code><b>metric</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Use metric or English units of measurement.</td>
        </tr>
        <tr id="control-location-locateoptions">
            <td><code><b>locateOptions</b></code></td>
            <td><code>Object </code></td>
            <td><code></code></td>
            <td>See <a href="/doc/maps/en/manual/map#geolocation-options">geo-location options</a>.</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Methods

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->


================================================
FILE: src/doc/en/manual/dg-ajax.md
================================================
## Asynchronous requests (AJAX)

{toc}

### DG.ajax

The DG.ajax function allows to send cross-domain AJAX requests.

    var promise = DG.ajax('http://www.geonames.org/postalCodeLookupJSON', {
        type: 'get',
        data: {
            postalcode: 10504,
            country: 'US'
        },
        success: function(data) {
            console.log('success', data);
        },
        error: function(error) {
            console.log('error', error);
        }
    });

    // to cancel the request:
    // promise.abort();

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.ajax</b>(
                <nobr>&lt;String&gt; <i>url</i>,</nobr>
                <nobr>&lt;<a href="#options">Ajax options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td><code>Promise</code></td>
            <td>Sends a request to the server and returns a Promise object with the abort method,
                with the help of which you can abort the sending of the request. Takes a URL as
                input parameters, where we will send you a request and an optional object of options.</td>
        </tr>
    </tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>data</b></code></td>
            <td><code>Object</code></td>
            <td><code>null</code></td>
            <td>The data that will be sent to the server.</td>
        </tr>
        <tr>
            <td><code><b>type</b></code></td>
            <td><code>String</code></td>
            <td><code>get</code></td>
            <td>Type of request ('get', 'post' or 'jsonp').</td>
        </tr>
        <tr>
            <td><code><b>success</b></code></td>
            <td><code>Function</code></td>
            <td><code>null</code></td>
            <td>A function which is triggered in case of successful server response.
                Takes the received data as a parameter.</td>
        </tr>
        <tr>
            <td><code><b>error</b></code></td>
            <td><code>Function</code></td>
            <td><code>null</code></td>
            <td>A function that is triggered when an error occurs.
                Takes the error information as a parameter.</td>
        </tr>
        <tr>
            <td><code><b>url</b></code></td>
            <td><code>String</code></td>
            <td><code>null</code></td>
            <td>The URL to which the request will be sent.</td>
        </tr>
        <tr>
            <td><code><b>timeout</b></code></td>
            <td><code>Number</code></td>
            <td><code>null</code></td>
            <td>Query timeout (in milliseconds).</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/en/manual/dg-entrance.md
================================================
## DG.Entrance

Allows to display an entrance to the building. The class supports simple animation and multiple inputs display.
Objects of entrances themselves represent arrows which change their scale together with zooming, but not lower
than the level 16, after which the arrows disappear from the map (until reaching an acceptable level of zooming).

{toc}

### DG.Entrance

#### Example of usage

Create and display the entrances to the building:

    var options = {vectors: [
        "LINESTRING(82.897079 54.980906,82.897191 54.980844)",
        "LINESTRING(82.897933 54.980649,82.898045 54.980587)",
        "LINESTRING(82.897071 54.980122,82.897226 54.98013)",
        "LINESTRING(82.897354 54.979515,82.89741 54.979599)",
        "LINESTRING(82.898498 54.979826,82.898386 54.979889)"
    ]}
    DG.entrance(options).addTo(map).show(true);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Usage</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Entrance</b>(
                <nobr>&lt;<a href="#entrance-options">Entrance options</a>&gt; <i>options</i> )</nobr>
            </code></td>
            <td><code>DG.entrance(&hellip;)</code></td>
            <td>Creates an entrance object based on the provided options.</td>
        </tr>
    </tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>vectors</b></code></td>
            <td><code>Array</td>
            <td><code>[]</code></td>
            <td><b>(a required parameter)</b>An array of vectors describing the entrances to the building.
                You can send several values in the array, if there is more than one entrance to the building.
                Each element should represent a string in WKT format: LINESTRING(lng0 lat0,lng1 lat1[,... lngN latN]),
                where the last coordinate pair should be a direct entrance point to the building, and the previous
                coordinates - be the route to this point. Throughout the route there should not be mutual intersections.</td>
        </tr>
        <tr>
            <td><code><b>fillColor</b></code></td>
            <td><code>String</td>
            <td><code>#0085a0</code></td>
            <td>The fill color of the arrows.</td>
        </tr>
        <tr>
            <td><code><b>strokeColor</b></code></td>
            <td><code>String</td>
            <td><code>#ffffff</code></td>
            <td>The outline color of the arrows.</td>
        </tr>
        <tr>
            <td><code><b>enableAnimation</b></code></td>
            <td><code>Boolean</td>
            <td><code>true</code></td>
            <td>Whether to animate the display of arrows when you change the zoom levels of the map and during the initial display.</td>
        </tr>
        <tr>
            <td><code><b>interactive</b></code></td>
            <td><code>Boolean</td>
            <td><code>false</code></td>
            <td>If the value is false, then the handler of the mouse actions is not called.</td>
        </tr>
        <tr>
            <td><code><b>autoClose</b></code></td>
            <td><code>Boolean</td>
            <td><code>true</code></td>
            <td>Whether to remove objects of entrances after adding new layers to the map.</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>addTo</b>(
                <nobr>&lt;<a href="#map">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Adds the object of entrances to the map.</td>
        </tr>
        <tr>
            <td><code><b>removeFrom</b>(
                <nobr>&lt;<a href="#map">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Removes the object of entrances from the map.</td>
        </tr>
        <tr>
            <td><code><b>show</b>(
                <nobr>&lt;fitBounds&gt; <i>boolean</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Displays entrances on the map. If <code>fitBounds</code> is set to <code>true</code>,
                then the map boundaries (and zoom level) are adjusted so that the user could see all
                the entrances on one screen.</td>
        </tr>
        <tr>
            <td><code><b>hide</b>()</code></td>

            <td><code>this</code></td>
            <td>Hides entrances. The objects themselves are not deleted from the map and the entrances
                can be re-displayed by calling the <code>show()</code> method.</td>
        </tr>
        <tr>
            <td><code><b>isShown</b>()</code></td>
            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the entrances are currently displayed on the map.</td>
        </tr>
        <tr>
            <td><code><b>setFillColor</b>()</code></td>
            <td><code>String</code></td>
            <td>Changes the fill color of the arrows.</td>
        </tr>
        <tr>
            <td><code><b>setStrokeColor</b>()</code></td>
            <td><code>String</code></td>
            <td>Changes the outline color of the arrows.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/en/manual/dg-external-modules.md
================================================
## External modules

Besides the possibility to connect one of the <a href="/doc/maps/en/manual/dg-loading#loading-pkg">packages</a>
of 2GIS modules, you can load other developers' modules from third-party servers. The maps API is compatible
with most of <a target="_blank" href="http://leafletjs.com/plugins.html">library modules</a> Leaflet.
You can also develop and connect <a href="https://github.com/2gis/maps-api-2.0/blob/master/CONTRIBUTING.md#%D0%9A%D0%B0%D0%BA-%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%D1%82%D1%8C-%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8C" target="_blank">your own module</a>.

{toc}

### Connection

To include external modules, use the <code>DG.plugin</code> function. Below we take a look at several examples of its use.

The usage of the <code>DG.plugin</code> function in the case where the module should be loaded before the map initialization:

    // loading of maps API code
    DG.then(function() {
        // module code loading
        return DG.plugin('https://raw.github.com/mlevans/leaflet-hash/master/leaflet-hash.js');
    })
    .then(function() {
        // map initialization
        var map = DG.map('map', {
            'center': [54.98, 82.89],
            'zoom': 13
        });
        // module initialization
        L.hash(map);
    });

If the module is not needed at the initial stage of work with the map, then you can use its deferred
loading and initialization (for example, when you click on the button):

    // loading of maps API code
    DG.then(function() {
        // map initialization
        map = DG.map('map', {
            'center': [54.98, 82.89],
            'zoom': 13
        });
    });

    // the code can be called on demand
    DG.then(function() {
        // module code loading
        return DG.plugin('https://raw.github.com/mlevans/leaflet-hash/master/leaflet-hash.js');
    }).then(function () {
        // module initialization
        L.hash(map);
    });

### DG.plugin

Is responsible for the loading of external modules. Function parameters:

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code>DG.plugin</b>(
                <nobr>&lt;String&gt; <i>url</i>&nbsp;|&nbsp;</nobr>
                <nobr>&lt;Array&gt; <i>[&lt;String&gt; url, &lt;String&gt; url, ...]</i></nobr>&nbsp;)
            </code></td>
            <td><code>Promise</code></td>
            <td>Loads the modules. The direct links to js and css files must be specified as parameters.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/en/manual/dg-label.md
================================================
## Labels

{toc}

### DG.Label

<code>DG.Label</code> class implements a small hint which may appear over a particular object on the map
(above a marker or a vector layer, for example). Also, the tips can be shown not only when you
hover the mouse over the object, but constantly, these tips are called static.

#### Example of usage

To enable the display of tips when you hover over the marker is quite easy:

    DG.marker([54.9502, 82.8380], {
        label : 'I'm a tip!'
    }).addTo(map);

For vector layers, you can specify a tip in this way, for example:

    DG.polyline([
        [55.02, 83.02],
        [54.97, 83.03],
        [54.95, 83.01],
        [54.98, 82.97]
    ], {
        label: 'I am a hint!'
    }).addTo(map);

To add a tip to an object that has been already created, you can call the <code>bindLabel</code> method:

    var marker = DG.marker([54.9502, 82.8980]).addTo(map);
    marker.bindLabel('I am a static tip!', { static: true });

<!--
TODO: JSAPI-3564
Showing autonomous static labels on the map:

    DG.label('I am an autonomous hint!')
        .setLatLng([54.9502, 82.8980]);
        .addTo(map);

#### Creation
...
-->

#### Options

When you call the <code>bindLabel</code> method, you can set the following options for the tooltip:

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><b><code>offset</code></b></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td><nobr><code>Point(12, 15)</code></nobr></td>
            <td>The offset of a tooltip container relative to the cursor position (the position
                of the marker in the case when used with a marker).</td>
        </tr>
        <tr>
            <td><b><code>className</code></b></td>
            <td><code>String</code></td>
            <td><code>'dg-label'</code></td>
            <td>The CSS class that will be assigned to the DOM element of the tooltip.</td>
        </tr>
        <tr id="label-static">
            <td><b><code>static</code></b></td>
            <td><code>Boolean</code></td>
            <td><code>false</code></td>
            <td>If the value is set to <code>true</code>, then the tooltip will be always visible
                (this option is available only for a marker tip).</td>
        </tr>
        <tr id="label-textdirection">
            <td><code><b>textDirection</b></code></td>
            <td><code>string</code></td>
            <td><code>'auto'</code></td>
            <td>The direction of the label text. The following values are possible: <code>'auto'</code>,
                <code>'rtl'</code>, <code>'ltr'</code>.</td>
        </tr>
    </tbody>
</table>

<!--
TODO: JSAPI-3564
#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>setContent</b>(&lt;String&gt; content)</code></td>
            <td><code>this</code></td>
            <td>Sets the contents of the tooltip.</td>
        </tr>
        <tr>
            <td><code><b>setLatLng</b>(&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; latlng)</code></td>
            <td><code>this</code></td>
            <td>Sets the geographical coordinates of the tip.</td>
        </tr>
        <tr>
            <td><code><b>getLatLng</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Returns the geographical coordinates of the tip.</td>
        </tr>
    </tbody>
</table>
-->


================================================
FILE: src/doc/en/manual/dg-loading.md
================================================
## Loading API

{toc}

### Description

Work with map is possible only after the code of Maps API is loaded to the browser.
There are several ways to download it.

### Easy way

First include the Maps API by adding the following code to the <code>head</code> section of the HTML page:

    <script src="https://maps.api.2gis.ru/2.0/loader.js?pkg=full"></script>

Then use the <code>DG.then</code> function, into which we will place the initialization code of the map:

    DG.then(function() {
        map = DG.map('map', {
            'center': [54.98, 82.89],
            'zoom': 13
        });
    });

Inside this function adds a handler for of the event of the page loading.
This very method was discussed in the [Quick start](/doc/maps/en/quickstart) section.

### npm

The Maps API can be included via npm:

    $ npm i 2gis-maps

After the package is installed, enable it using <code>require</code>:

    var DG = require('2gis-maps');
    var map = DG.map('map', {
        'center': [54.98, 82.89],
        'zoom': 13
    });

Please note that when you use the npm package, there is no need to use <code>DG.then</code>.

### Download on demand

You can load the Maps API at the very moment when you need the map. To do this, you need to add the
<code>lazy=true</code> parameter to the URL used to include API:

    <script src="https://maps.api.2gis.ru/2.0/loader.js?pkg=full&lazy=true"></script>

Then, at the right time (for example, when pressing the button) you must call the <code>DG.then</code> function:

    DG.then(function() {
        map = DG.map('map', {
            'center': [54.98, 82.89],
            'zoom': 13
        });
    });

### Connection options

The following are all options that can take the URL of the Maps API loading:

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="loading-pkg">
            <td><code>pkg</code></td>
            <td><code>full</code></td>
            <td>Package of loadable modules. Currently, 2 packages are supported: <code>full</code> — all API modules;
                <code>basic</code> — basic functionality (popups, markers, vector objects).</td>
        </tr>
        <tr>
            <td><code>skin</code></td>
            <td><code>dark</code></td>
            <td>The theme of controls (light or dark). Takes the value <code>light</code> or <code>dark</code>.</td>
        </tr>
        <tr>
            <td><code>lazy</code></td>
            <td><code>false</code></td>
            <td>If you specify the <code>true</code> value, then the Maps API will load with delay,
                when you first call <code>DG.then</code>.</td>
        </tr>
    </tbody>
</table>

### DG.then function

As described earlier, the function <code>DG.then</code> is responsible for tracking the moment of loading the Maps API
and adding handlers for this action. Function parameters:

<table>
    <thead>
        <tr>
            <th>Function</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code>DG.then</b>(
                <nobr>&lt;Function&gt; <i>resolve</i>,</nobr>
                <nobr>&lt;Function&gt; <i>reject</i></nobr>&nbsp;)
            </code></td>
            <td><code>Promise</code></td>
            <td>Registers API loading handlers. Parameters: <code>resolve</code> is a function triggered
                in case of a successful loading of the Maps API, <code>reject</code> is a function triggered
                in case of server errors.</td>
        </tr>
    </tbody>
</table>

The call of the <code>DG.then</code> function at any time after the API loading will be immediately executed by the handler.

================================================
FILE: src/doc/en/manual/dg-locale.md
================================================
## Localization

{toc}

### Description

Maps API provides a possibility to display elements of user interface in several languages.

The default language is the same as that of the root html tag:

    <html lang="it">
        <head></head>
        <body></body>
    </html>

If the language is not specified in the root tag, then the default language — Russian — will be used.

Get or dynamically change the language using the corresponding methods of the map
<a href="/doc/maps/en/manual/map#map-getlang">getLang</a> and <a href="/doc/maps/en/manual/map#map-setlang">setLang</a>:

    map.setLang('it');
    map.getLang(); // returns 'it'

or by initializing the map with the following option <a href="/doc/maps/en/manual/map#map-currentlang">currentLang</a>.

Currently supports the following languages:

* en &mdash; English;
* ru &mdash; Russian;
* it &mdash; Italian;
* cs &mdash; Czech;
* es &mdash; Spanish;
* ar &mdash; Arabic.

### DG.Locale

Performs <a href="/doc/maps/en/manual/dg-locale">the translation of the user interface</a>.


Adds two methods to the map: <a href="/doc/maps/en/manual/map#map-setlang">setLang</a>
and <a href="/doc/maps/en/manual/map#map-getlang">getLang</a>. There is also a DG object.Locale object,
which you can add to any <a href="/doc/maps/en/manual/dg-external-modules">external module</a>,
and there will appear the t method which you can use to perform a translation.
Classes of modules, to which DG.Locale is added must contain the <code>_map</code> property and the <code>Dictionary</code>
static property inside.

The basic dictionary for all dictionaries is <code>DG.Dictionary</code>, which stores the translation rules
for words in plural forms (plural rules). When you create a module which uses its own dictionaries,
you need to put them to the lang folder. For example, if you want to use Italian and Russian languages,
you need to create the <code>lang/it.js</code> and <code>lang/ru.js</code> files. Examples of creation of dictionaries are given below.

#### Example of usage

Mixing of localization features to the module:

    DG.LocaleExample = DG.Control.extend({
        includes: DG.Locale,
        statics: {
            Dictionary: {}
        }
        ...
    }

Subscribe to the langchange event:

    this._map.on('langchange', this._updateText, this);

The translation of the string to the current language of the map:

    container.innerHTML = this.t("{n} people", 16700000) + ' ' + this.t("regularly use 2GIS");

Create your own dictionaries in Italian and Russian:

lang/it.js file contents:

    DG.LocaleExample.Dictionary.it = DG.extend({
        "{n} people" : ["{n} utente", "{n} utenti"],
        "regularly use 2GIS" : "utilizzano regolarmente 2GIS"
    }, DG.Dictionary.it);

lang/ru.js file contents:

     DG.LocaleExample.Dictionary.ru = DG.extend({
        "{n} people" : ["{n} пользователь", "{n} пользователя", "{n} пользователей"],
        "regularly use 2GIS" : "регулярно используют 2GIS"
    }, DG.Dictionary.ru);


================================================
FILE: src/doc/en/manual/dg-metalayers.md
================================================
## Meta Layers

Allows you to create additional layers of meta information and add them to the map.

{toc}

### DG.Meta.layer

Inherits from <a href="/doc/maps/en/manual/base-classes#dglayer"><code>DG.Layer</code></a>.

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Usage</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Meta.layer</b>(
                <nobr>&lt;String&gt; <i>source</i>,</nobr>
                <nobr>&lt;<a href="#options">DG.Meta.layer options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td><code>DG.Meta.layer(&hellip;)</code></td>
            <td>Creates additional layer with meta-information. Takes the source URL as a parameter
                with which the tiles of an additional layer are available.</td>
        </tr>
    </tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>tileSize</b></code></td>
            <td><code>Number</code></td>
            <td><code>256</code></td>
            <td>The tile size (width and height in pixels, it is assumed that the tile is square).</td>
        </tr>
        <tr>
            <td><code><b>minZoom</b></code></td>
            <td><code>Number</code></td>
            <td><code>0</code></td>
            <td>The minimum zoom level.</td>
        </tr>
        <tr>
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number</code></td>
            <td><code>18</code></td>
            <td>The maximum zoom level.</td>
        </tr>
        <tr>
            <td><code><b>zoomOffset</b></code></td>
            <td><code>Number</code></td>
            <td><code>0</code></td>
            <td>Value which will shift the zoom level in the tile's address.</td>
        </tr>
        <tr>
            <td><code><b>eventBubbling</b></code></td>
            <td><code>String</code></td>
            <td><code><span class="string">'transparent'</span>||<span class="string">'layer'</span></td>
            <td>The way in which meta-layer handles events. Accepts values <b>layer</b>
                or <b>transparent</b> (default):<ul><li>transparent &mdash; meta-layer receives all of the events
                and carry them to the map</li><li>layer &mdash; meta-layer receives all of the events and stops
                them after processing</li></ul></td>
        </tr>
    </tbody>
</table>

#### Events

You can subscribe to the following events using
<a href="/doc/maps/en/manual/base-classes#dgevented">these</a> methods.

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>mouseover</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#metaevent">MetaEvent</a></code>
            <td>Called when you hover the mouse over the additional layer object.</td>
        </tr>
        <tr>
            <td><code><b>mouseout</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#metaevent">MetaEvent</a></code>
            <td>Called when the mouse cursor leaves the bounds of an additional layer object.</td>
        </tr>
        <tr>
          <td><code><b>mousemove</b></code></td>
          <td><code><a href="/doc/maps/en/manual/base-classes#metaevent">MetaEvent</a></code></td>
          <td>Called when the mouse cursor moves over an additional layer object.</td>
        </tr>
        <tr>
          <td><code><b>click</b></code></td>
          <td><code><a href="/doc/maps/en/manual/base-classes#metaevent">MetaEvent</a></code></td>
          <td>Called when the mouse click in the additional layer.</td>
        </tr>
        <tr>
          <td><code><b>dblclick</b></code></td>
          <td><code><a href="/doc/maps/en/manual/base-classes#metaevent">MetaEvent</a></code></td>
          <td>Called when the mouse double-click in the additional layer.</td>
        </tr>
        <tr>
          <td><code><b>mousedown</b></code></td>
          <td><code><a href="/doc/maps/en/manual/base-classes#metaevent">MetaEvent</a></code></td>
          <td>Called when the mouse button is pressed while the cursor is over the additional layer.</td>
        </tr>
        <tr>
          <td><code><b>contextmenu</b></code></td>
          <td><code><a href="/doc/maps/en/manual/base-classes#metaevent">MetaEvent</a></code></td>
          <td>Called when you click the right mouse button in the additional layer.</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>getOrigin</b>()</code></td>
            <td><code>Object</code></td>
            <td>Returns origin-instance of additional layer.</td>
        </tr>
    </tbody>
</table>

### DG.Meta.origin

Works with the meta data of a layer, inherits from <a href="/doc/maps/en/manual/base-classes#dgclass"><code>DG.Class</code></a>.

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Usage</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Meta.origin</b>(
                <nobr>&lt;String&gt; <i>source</i>,</nobr>
                <nobr>&lt;DG.Meta.layer options&gt; <i>options?</i> )</nobr>
            </code></td>
            <td><code>DG.Meta.origin(&hellip;)</code></td>
            <td>Creates an instance for work with the meta layer data. Takes the source URL as a parameter
                with which the tiles of an additional layer are available.</td>
        </tr>
    </tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>subdomains</b></code></td>
            <td><code>String</code> или <code>String[]</code></td>
            <td><code>'0123'</code></td>
            <td>Tile service subdomains. Can be sent as one string (where each letter &mdash;
                is a subdomain name) or as an array of strings.</td>
        </tr>
        <tr>
            <td><code><b>dataFilter</b></code></td>
            <td><code>Function</code></td>
            <td><code>null</code></td>
            <td>Optional parameter, which takes a function to filter or convert the meta data
                received from the server.</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>getTileData</b>(
                <nobr>&lt;Object&gt; <i>coord</i>)</nobr>
            </code>
            <td><code>Object</code></td>
            <td>Returns the metadata of the meta layer for the specified tile.</td>
        </tr>
        <tr>
            <td><code><b>setTileData</b>(
                <nobr>&lt;String&gt;/&lt;Object&gt; <i>coord</i>,</nobr>
                <nobr>&lt;Object&gt; <i>data</i>)</nobr>
            </code>
            <td><code>this</code></td>
            <td>Assigns data for the tile with the coord key.</td>
        </tr>
        <tr>
            <td><code><b>flush</b>()</code></td>
            <td><code>this</code></td>
            <td>Clear cached data for all tiles.</td>
        </tr>
        <tr>
            <td><code><b>setURL</b>(
                <nobr>&lt;String&gt; <i>url</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>flush?</i>)</nobr>
            </code>
            <td><code>this</code></td>
            <td>Sets the url used to get the meta data. If the parameter flush=true,
                the cached data will be cleared.</td>
        </tr>
        <tr>
            <td><code><b>getTileKey</b>(
                <nobr>&lt;Object&gt; <i>coord</i>)</nobr>
            </code>
            <td><code>String</code></td>
            <td>Returns the key of the tile as a string.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/en/manual/dg-project-detector.md
================================================
## 2GIS Project Detection Module

Project is agglomeration, which includes a major city and the surrounding areas.
This plugin allows to get information about the project which is being viewed at the current moment of time.

{toc}

### Examples of usage

Subscribe to the projectchange event:

    map.on('projectchange', function (e) {
        console.log(e);
    });

Subscribe to the projectleave event:

    map.on('projectleave', function (e) {
       console.log(e);
    });

### Events

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>projectchange</td>
            <td>ProjectEvent</td>
            <td>Occurs when the user goes from one project to another.</td>
        </tr>
        <tr>
            <td>projectleave</td>
            <td>ProjectEvent</td>
            <td>Occurs when the user is outside of the current project.</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>getProjectsList</td>
            <td>Object</td>
            <td>Returns all available projects.</td>
        </tr>
        <tr>
            <td>getProject</td>
            <td>Object</td>
            <td>Returns the current project.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/en/manual/dg-ruler.md
================================================
## Ruler

Displays a ruler on the map that allows to measure distances between geographical points.

{toc}

### DG.Ruler

#### Example of usage

Create and display a ruler on the map:

    var latLngs = [
        [51.7314, 36.1938],
        [51.7307, 36.1894],
        [51.7297, 36.1926],
        [51.7299, 36.1968],
        [51.7307, 36.1968]]
    DG.ruler(latLngs).addTo(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Usage</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Ruler</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>[]&gt; <i>latlngs</i>,</nobr>
                <nobr>&lt;<a href="#dgruler-options">Ruler options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td><code>DG.ruler(&hellip;)</code></td>
            <td>Creates the ruler object by the given array of geographical points and optional object of options.</td>
        </tr>
    </tbody>
</table>

#### Options

<table id='dgruler-options'>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>editable</b></code></td>
            <td><code>Boolean</code></td>
            <td><code><span class="string">'true'</span></td>
            <td>Is it possible to change the intermediate points of the ruler.</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>addTo</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Adds a ruler to the map.</td>
        </tr>
        <tr>
            <td><code><b>getTotalDistance</b>()</nobr></code></td>
            <td><code>Number</code></td>
            <td>Returns the distance (in meters) between the start and end points.</td>
        </tr>
        <tr>
            <td><code><b>addLatLng</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Adds a point to the ruler.</td>
        </tr>
        <tr>
            <td><code><b>setLatLngs</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>[]&gt; <i>latlngs</i> )</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Replaces all the pixels of the ruler with an array of the transferred geographical locations.</td>
        </tr>
        <tr>
            <td><code><b>getLatLngs</b>()</code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>[]</code></td>
            <td>Returns an array of points of the ruler.</td>
        </tr>
        <tr>
            <td><code><b>spliceLatLngs</b>(
                <nobr>&lt;Number&gt; <i>index</i></nobr>,
                <nobr>&lt;Number&gt; <i>pointsToRemove</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng?</i>, &hellip; )</nobr>
            </code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>[]</code></td>
            <td>Allows you to add, remove or replace the points in the ruler. The syntax is similar
                <a target="_blank" href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice">Array#splice</a>.
                Returns an array of remote points.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/en/manual/dg-traffic.md
================================================
## Traffic information

Creates a layer with information about traffic jams. When you hover over a section of a road,
it displays additional meta-information.

{toc}

### DG.Traffic

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Usage</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Traffic</b>(
                <nobr>&lt;<a href="#options">DG.Traffic options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td><code>DG.Traffic(&hellip;)</code></td>
            <td>Creates a traffic jams layer.</td>
        </tr>
    </tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>disableLabel</b></code></td>
            <td><code>Boolean</code></td>
            <td><code><span class="string">false</span></td>
            <td>If you send the value= true, then, when you hover over a section of a road,
                the additional information will not be displayed.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/en/manual/dg-wkt.md
================================================
## Well-known text


Is used to obtain the vector layers of API maps based on their description in
<a target="_blank" href="http://en.wikipedia.org/wiki/Well-known_text">WKT format</a>.

{toc}

### DG.Wkt

#### Example of usage

Reads the description of the polygon in WKT format and displays it on the map:

    var polygonComponents = 'POLYGON((82.91699 55.042136, 82.917522 55.040187, 82.918063 55.040235, 82.917540 55.042184,82.91699 55.042136))';
    DG.Wkt.geoJsonLayer(polygonComponents).addTo(map);

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Wkt.toGeoJSON</b>(
                <nobr>&lt;String&gt; <i>wkt</i>)</nobr>
            </code></td>
            <td><code>geoJSON</code></td>
            <td>Reads a string in WKT format and verifies its correctness. Returns
                <a href="http://geojson.org/geojson-spec.html" target="_blank">GeoJSON</a>.</td>
        </tr>
        <tr>
            <td><code><b>DG.Wkt.toLatLngs</b>(
                <nobr>&lt;String | Array&gt; <i>wkt</i>)</nobr>
            </code></td>
            <td><code>Array</code></td>
            <td>Reads a string in WKT format and returns the pixel array in the
                <a href="/doc/maps/en/manual/basic-types/#dglatlng">LatLng</a> format (its internal representation).
                Can take an array of WKT strings.</td>
        </tr>
        <tr>
            <td><code><b>DG.Wkt.geoJsonLayer</b>(
                <nobr>&lt;String&gt; <i>wkt</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/en/manual/other-layers#geojson-option">GeoJSON options</a>&gt; <i>options?</i>)</nobr></code></td>
            <td><code>Object</code></td>
            <td>Creates a GeoJSON layer. Takes a string in WKT format to display the data on the map
                and the object of options. Generates a vector layer of maps AP based on the data read
                with the DG.Wkt.toGeoJSON method. This method supports all the options of the constructor
                of the <a href="/doc/maps/en/manual/other-layers#dggeojson">DG.GeoJSON</a> class.
                For example, you can send the <code>DG.Wkt.geoJsonLayer(polygonComponents, {clickable:false})</code>
                parameter, to make the layer non-clickable.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/en/manual/dom-utils.md
================================================
## Working with DOM

{toc}

### DG.DomEvent

Utility functions to work with the <a href="https://developer.mozilla.org/docs/Web/API/Event">DOM events</a>.

#### Functions

<table>
    <thead>
        <tr>
            <th>Function</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="domevent-on">
            <td><code><b>on</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
                <nobr>&lt;String&gt; <i>types</i>,</nobr>
                <nobr>&lt;Function&gt; <i>fn</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

		    <td><code>this</code></td>
            <td>Adds a listener function (<code>fn</code>) to a particular DOM event type of the
                element <code>el</code>. You can optionally specify the context of the listener
                (object the <code>this</code> keyword will point to). You can also pass several
                space-separated types (e.g. <code>&#39;click dblclick&#39;</code>).</td>
        </tr>
        <tr>
            <td><code><b>on</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
                <nobr>&lt;Object&gt; <i>eventMap</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Adds a set of type/listener pairs, e.g. <code>{click: onClick, mousemove: onMouseMove}</code></td>
        </tr>
        <tr id="domevent-off">
            <td><code><b>off</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
                <nobr>&lt;String&gt; <i>types</i>,</nobr>
                <nobr>&lt;Function&gt; <i>fn</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Removes a previously added listener function. If no function is specified,
                it will remove all the listeners of that particular DOM event from the element.
                Note that if you passed a custom context to on, you must pass the same
                context to <code>off</code> in order to remove the listener.</td>
        </tr>
        <tr>
            <td><code><b>off</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
                <nobr>&lt;Object&gt; <i>eventMap</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Removes a set of type/listener pairs.</td>
        </tr>
        <tr id="domevent-stoppropagation">
            <td><code><b>stopPropagation</b>(
                <nobr>&lt;DOMEvent&gt; <i>ev</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Stop the given event from propagation to parent elements. Used inside the listener functions:
                <pre><code>DG.DomEvent.on(div, &#39;click&#39;, function (ev) {
    DG.DomEvent.stopPropagation(ev);
});</code></pre></td>
        </tr>
        <tr id="domevent-disablescrollpropagation">
            <td><code><b>disableScrollPropagation</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Adds <code>stopPropagation</code> to the element&#39;s <code>&#39;mousewheel&#39;</code> events (plus browser variants).</td>
        </tr>
        <tr id="domevent-disableclickpropagation">
            <td><code><b>disableClickPropagation</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Adds <code>stopPropagation</code> to the element&#39;s <code>&#39;click&#39;</code>, <code>&#39;doubleclick&#39;</code>,
                <code>&#39;mousedown&#39;</code> and <code>&#39;touchstart&#39;</code> events (plus browser variants).</td>
        </tr>
        <tr id="domevent-preventdefault">
            <td><code><b>preventDefault</b>(
                <nobr>&lt;DOMEvent&gt; <i>ev</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Prevents the default action of the DOM Event <code>ev</code> from happening (such as
                following a link in the href of the a element, or doing a POST request
                with page reload when a <code>&lt;form&gt;</code> is submitted).
                Use it inside listener functions.</td>
        </tr>
        <tr id="domevent-stop">
            <td><code><b>stop</b>(
                <nobr>&lt;DOMEvent&gt; <i>ev</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Does <code>stopPropagation</code> and <code>preventDefault</code> at the same time.</td>
        </tr>
        <tr id="domevent-getmouseposition">
            <td><code><b>getMousePosition</b>(
                <nobr>&lt;DOMEvent&gt; <i>ev</i>,</nobr>
                <nobr>&lt;HTMLElement&gt; <i>container?</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Gets normalized mouse position from a DOM event relative to the
                <code>container</code> or to the whole page if not specified.</td>
        </tr>
        <tr id="domevent-getwheeldelta">
            <td><code><b>getWheelDelta</b>(
                <nobr>&lt;DOMEvent&gt; <i>ev</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Gets normalized wheel delta from a mousewheel DOM event, in vertical
                pixels scrolled (negative if scrolling down).
                Events from pointing devices without precise scrolling are mapped to
                a best guess of between 50-60 pixels.</td>
        </tr>
        <tr id="domevent-addlistener">
            <td><code><b>addListener</b>(
                <nobr><i>…</i> )</nobr>
            </code></td>

		    <td><code>this</code></td>
            <td>Alias to <a href="#domevent-on"><code>DG.DomEvent.on</code></a></td>
        </tr>
        <tr id="domevent-removelistener">
            <td><code><b>removeListener</b>(
                <nobr><i>…</i> )</nobr>
            </code></td>

		    <td><code>this</code></td>
            <td>Alias to <a href="#domevent-off"><code>DG.DomEvent.off</code></a></td>
        </tr>
    </tbody>
</table>

### DG.DomUtil

Utility functions to work with the <a href="https://developer.mozilla.org/docs/Web/API/Document_Object_Model">DOM</a> tree.

#### Functions

<table>
    <thead>
        <tr>
            <th>Function</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="domutil-get">
    		<td><code><b>get</b>(
    		    <nobr>&lt;String|HTMLElement&gt; <i>id</i> )</nobr>
    		</code></td>

		    <td><code>HTMLElement</code></td>
            <td>Returns an element given its DOM id, or returns the element itself
                if it was passed directly.</td>
	    </tr>
        <tr id="domutil-getstyle">
    		<td><code><b>getStyle</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;String&gt; <i>styleAttrib</i> )</nobr>
		    </code></td>

		    <td><code>String</code></td>
		    <td>Returns the value for a certain style attribute on an element,
                including computed values or values set through CSS.</td>
    	</tr>
        <tr id="domutil-create">
		    <td><code><b>create</b>(
		        <nobr>&lt;String&gt; <i>tagName</i>,</nobr>
		        <nobr>&lt;String&gt; <i>className?</i>,</nobr>
		        <nobr>&lt;HTMLElement&gt; <i>container?</i> )</nobr>
		    </code></td>

		    <td><code>HTMLElement</code></td>
            <td>Creates an HTML element with <code>tagName</code>, sets its class to <code>className</code>,
                and optionally appends it to <code>container</code> element.</td>
    	</tr>
        <tr id="domutil-remove">
		    <td><code><b>remove</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

		    <td><code></code></td>
		    <td>Removes <code>el</code> from its parent element</td>
	    </tr>
        <tr id="domutil-empty">
		    <td><code><b>empty</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

    		<td><code></code></td>
		    <td>Removes all of <code>el</code>&#39;s children elements from <code>el</code></td>
    	</tr>
        <tr id="domutil-tofront">
		    <td><code><b>toFront</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

    		<td><code></code></td>
    		<td>Makes <code>el</code> the last children of its parent, so it renders in front of the other children.</td>
    	</tr>
        <tr id="domutil-toback">
		    <td><code><b>toBack</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

		    <td><code></code></td>
		    <td>Makes <code>el</code> the first children of its parent, so it renders back from the other children.</td>
	    </tr>
        <tr id="domutil-hasclass">
		    <td><code><b>hasClass</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;String&gt; <i>name</i> )</nobr>
		    </code></td>

		    <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the element&#39;s class attribute contains <code>name</code>.</td>
	    </tr>
        <tr id="domutil-addclass">
    		<td><code><b>addClass</b>(
    		    <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
    		    <nobr>&lt;String&gt; <i>name</i> )</nobr>
    		</code></td>

    		<td><code></code></td>
            <td>Adds <code>name</code> to the element&#39;s class attribute.</td>
    	</tr>
        <tr id="domutil-removeclass">
		    <td><code><b>removeClass</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;String&gt; <i>name</i> )</nobr>
		    </code></td>

		    <td><code></code></td>
            <td>Removes <code>name</code> from the element&#39;s class attribute.</td>
	    </tr>
        <tr id="domutil-setclass">
		    <td><code><b>setClass</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;String&gt; <i>name</i> )</nobr>
		    </code></td>

		    <td><code></code></td>
		    <td>Sets the element&#39;s class.</td>
	    </tr>
        <tr id="domutil-getclass">
    		<td><code><b>getClass</b>(
    		    <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
    		</code></td>

    		<td><code>String</code></td>
    		<td>Returns the element&#39;s class.</td>
    	</tr>
        <tr id="domutil-setopacity">
    		<td><code><b>setOpacity</b>(
    		    <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
    		    <nobr>&lt;Number&gt; <i>opacity</i> )</nobr>
    		</code></td>

    		<td><code></code></td>
    		<td>Set the opacity of an element. <code>opacity</code> must be a number from <code>0</code> to <code>1</code>.</td>
    	</tr>
        <tr id="domutil-testprop">
		    <td><code><b>testProp</b>(
		        <nobr>&lt;String[]&gt; <i>props</i> )</nobr>
		    </code></td>

		    <td><code>String|false</code></td>
		    <td>Goes through the array of style names and returns the first name
                that is a valid style name for an element. If no such name is found,
                it returns false. Useful for vendor-prefixed styles like <code>transform</code>.</td>
	    </tr>
        <tr id="domutil-settransform">
		    <td><code><b>setTransform</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>offset</i>,</nobr>
		        <nobr>&lt;Number&gt; <i>scale?</i> )</nobr>
		    </code></td>

    		<td><code></code></td>
    		<td>Resets the 3D CSS transform of <code>el</code> so it is translated by <code>offset</code> pixels
                and optionally scaled by <code>scale</code>. Does not have an effect if the
                browser doesn&#39;t support 3D CSS transforms.</td>
	    </tr>
        <tr id="domutil-setposition">
    		<td><code><b>setPosition</b>(
    		    <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
    		    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>position</i> )</nobr>
    		</code></td>

    		<td><code></code></td>
    		<td>Sets the position of <code>el</code> to coordinates specified by <code>position</code>,
                using CSS translate or top/left positioning depending on the browser
                (used by Leaflet internally to position its layers).</td>
	    </tr>
        <tr id="domutil-getposition">
		    <td><code><b>getPosition</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

    		<td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
		    <td>Returns the coordinates of an element previously positioned with setPosition.</td>
	    </tr>
        <tr id="domutil-disabletextselection">
    		<td><code><b>disableTextSelection</b>()</code></td>

    		<td><code></code></td>
    		<td>Prevents the user from generating <code>selectstart</code> DOM events, usually generated
                when the user drags the mouse through a page with text. Used internally
                by Leaflet to override the behaviour of any click-and-drag interaction on
                the map. Affects drag interactions on the whole document.</td>
	    </tr>
        <tr id="domutil-enabletextselection">
		    <td><code><b>enableTextSelection</b>()</code></td>

		    <td><code></code></td>
		    <td>Cancels the effects of a previous <a href="#domutil-disabletextselection"><code>DG.DomUtil.disableTextSelection</code></a>.</td>
	    </tr>
        <tr id="domutil-disableimagedrag">
		    <td><code><b>disableImageDrag</b>()</code></td>

    		<td><code></code></td>
    		<td>As <a href="#domutil-disabletextselection"><code>DG.DomUtil.disableTextSelection</code></a>, but
                for <code>dragstart</code> DOM events, usually generated when the user drags an image.</td>
	    </tr>
	    <tr id="domutil-enableimagedrag">
    		<td><code><b>enableImageDrag</b>()</code></td>

    		<td><code></code></td>
    		<td>Cancels the effects of a previous <a href="#domutil-disabletextselection"><code>DG.DomUtil.disableImageDrag</code></a>.</td>
    	</tr>
        <tr id="domutil-preventoutline">
		    <td><code><b>preventOutline</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

    		<td><code></code></td>
    		<td>Makes the <a href="https://developer.mozilla.org/docs/Web/CSS/outline">outline</a>
                of the element <code>el</code> invisible. Used internally by Leaflet to prevent
                focusable elements from displaying an outline when the user performs a
                drag interaction on them.</td>
    	</tr>
    	<tr id="domutil-restoreoutline">
	    	<td><code><b>restoreOutline</b>()</code></td>

    		<td><code></code></td>
    		<td>Cancels the effects of a previous <a href="#domutil-preventoutline"><code>DG.DomUtil.preventOutline</code></a>.</td>
    	</tr>
    </tbody>
</table>

#### Properties

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>TRANSFORM</b></code></td>
            <td><code>String</code></td>
            <td>Vendor-prefixed fransform style name (e.g. <code>&#39;webkitTransform&#39;</code> for WebKit).</td>
        </tr>
        <tr>
            <td><code><b>TRANSITION</b></code></td>
            <td><code>String</code></td>
            <td>Vendor-prefixed transition style name.</td>
        </tr>
    </tbody>
</table>

### DG.PosAnimation

Used internally for panning animations, utilizing CSS3 Transitions for modern browsers and a timer fallback for IE6-9.

    var fx = new DG.PosAnimation();
    fx.run(el, [300, 500], 0.5);

#### Events

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="posanimation-start">
            <td><code><b>start</b></code></td>
            <td><code><a href="/doc/maps/en/manual/events#event">Event</a></code></td>
            <td>Fired when the animation starts.</td>
        </tr>
        <tr id="posanimation-step">
            <td><code><b>step</b></code></td>
            <td><code><a href="/doc/maps/en/manual/events#event">Event</a></code></td>
            <td>Fired continuously during the animation.</td>
        </tr>
        <tr id="posanimation-end">
            <td><code><b>end</b></code></td>
            <td><code><a href="/doc/maps/en/manual/events#event">Event</a></code></td>
            <td>Fired when the animation ends.</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="posanimation-run">
		    <td><code><b>run</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>newPos</i>,</nobr>
		        <nobr>&lt;Number&gt; <i>duration?</i>,</nobr>
		        <nobr>&lt;Number&gt; <i>easeLinearity?</i>)</nobr>
		    </code></td>

		    <td><code></code></td>
            <td>Run an animation of a given element to a new position, optionally setting
                duration in seconds (<code>0.25</code> by default) and easing linearity factor (3rd
                argument of the <a href="http://cubic-bezier.com/#0,0,.5,1">cubic bezier curve</a>,
                <code>0.5</code> by default).</td>
	    </tr>
	    <tr id="posanimation-stop">
		    <td><code><b>stop</b>()</code></td>
		    <td><code></code></td>
		    <td>Stops the animation (if currently running).</td>
	    </tr>
    </tbody>
</table>

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->

### DG.Draggable

A class for making DOM elements draggable (including touch support).
Used internally for map and marker dragging. Only works for elements
that were positioned with [DG.DomUtil.setPosition](#domutil-setposition)

    var draggable = new DG.Draggable(elementToDrag);
    draggable.enable();

#### Properties

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="draggable-clicktolerance">
		    <td><code><b>clickTolerance</b></code></td>
		    <td><code>Number</code></td>
		    <td><code>3</code></td>
		    <td>The max number of pixels a user can shift the mouse pointer during a click
                for it to be considered a valid click (as opposed to a mouse drag).</td>
    	</tr>
    </tbody>
</table>

#### Events

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
    	<tr id="draggable-down">
    		<td><code><b>down</b></code></td>
    		<td><code><a href="/doc/maps/en/manual/events#event">Event</a></code></td>
            <td>Fired when a drag is about to start.</td>
    	</tr>
    	<tr id="draggable-dragstart">
    		<td><code><b>dragstart</b></code></td>
    		<td><code><a href="/doc/maps/en/manual/events#event">Event</a></code></td>
            <td>Fired when a drag starts</td>
    	</tr>
    	<tr id="draggable-predrag">
    		<td><code><b>predrag</b></code></td>
    		<td><code><a href="/doc/maps/en/manual/events#event">Event</a></code></td>
            <td>Fired continuously during dragging <em>before</em> each corresponding
                update of the element&#39;s position.
                Fired continuously during dragging.</td>
	    </tr>
	    <tr id="draggable-dragend">
    		<td><code><b>dragend</b></code></td>
    		<td><code><a href="/doc/maps/en/manual/events#event">Event</a></code></td>
            <td>Fired when the drag ends.</td>
	    </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="draggable-enable">
            <td><code><b>enable</b>()</code></td>
            <td><code></code></td>
            <td>Enables the dragging ability.</td>
        </tr>
        <tr id="draggable-disable">
            <td><code><b>disable</b>()</code></td>
            <td><code></code></td>
            <td>Disables the dragging ability.</td>
        </td>
    </tbody>
</table>

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/en/manual/map.md
================================================
## Map

This section describes the central class of the maps API which is used to create a map on a page and manipulate it.

{toc}

### DG.Map

#### Usage example

Initialize the map on the &quot;map&quot; div with a given center and zoom:

    var map = DG.map('map', {
        center: [54.98, 82.89],
        zoom: 13
    });

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-l-map">
            <td><code><b>DG.map</b>(
                <nobr>&lt;String&gt; <i>id</i></nobr>,
                <nobr>&lt;Map options&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Instantiates a map object given the DOM ID of a <code>&lt;div&gt;</code> element
                and optionally an object literal with <code>Map options</code>.</td>
        </tr>
        <tr>
            <td><code><b>DG.map</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i></nobr>,
                <nobr>&lt;Map options&gt; <i>options?</i>)</nobr>
            </code></td>
            <td>Instantiates a map object given an instance of a <code>&lt;div&gt;</code> HTML element
                and optionally an object literal with <code>Map options</code>.</td>
        </tr>
    </tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-prefercanvas">
            <td><code><b>preferCanvas</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Whether <a href="/doc/maps/en/manual/vector-layers#dgpath"><code>Path</code></a>s
                should be rendered on a <a href="/doc/maps/en/manual/vector-layers#dgcanvas">
                <code>Canvas</code></a> renderer. By default, all <code>Path</code>s are
                rendered in a <a href="/doc/maps/en/manual/vector-layers#dgsvg"><code>SVG</code></a> renderer.
            </td>
        </tr>
        <tr id="map-protocol">
            <td><code><b>protocol</b></code></td>
            <td><code>String </code></td>
            <td><code>''</code></td>
            <td>Network protocol used in tiles requests.
            </td>
        </tr>
    </tbody>
</table>

##### Control Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="map-zoomcontrol">
            <td><code><b>zoomControl</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether a <a href="/doc/maps/en/manual/controls#dgcontrolzoom">zoom control</a>
                is added to the map by default.
            </td>
        </tr>
        <tr id="map-fullscreencontrol">
            <td><code><b>fullscreenControl</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether a <a href="/doc/maps/en/manual/controls#dgcontrolfullscreen">fullscreen control</a>
                is added to the map by default.
            </td>
        </tr>
    </tbody>
</table>

##### Interaction Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-closepopuponclick">
            <td><code><b>closePopupOnClick</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Set it to <code>false</code> if you don&#39;t want popups to close when user clicks the map.</td>
        </tr>
        <tr id="map-zoomsnap">
            <td><code><b>zoomSnap</b></code></td>
            <td><code>Number </code></td>
            <td><code>1</code></td>
            <td>Forces the map&#39;s zoom level to always be a multiple of this,
                particularly right after a <a href="#map-fitbounds"><code>fitBounds()</code></a>
                or a pinch-zoom. By default, the zoom level snaps to the nearest integer;
                lower values (e.g. <code>0.5</code> or <code>0.1</code>) allow for greater
                granularity. A value of <code>0</code> means the zoom level will not be snapped after
                <code>fitBounds</code> or a pinch-zoom.
            </td>
        </tr>
        <tr id="map-zoomdelta">
            <td><code><b>zoomDelta</b></code></td>
            <td><code>Number </code></td>
            <td><code>1</code></td>
            <td>Controls how much the map&#39;s zoom level will change after a
                <a href="#map-zoomin"><code>zoomIn()</code></a>,
                <a href="#map-zoomout"><code>zoomOut()</code></a>, pressing <code>+</code> or
                <code>-</code> on the keyboard, or using the
                <a href="/doc/maps/en/manual/controls#dgcontrolzoom">zoom controls</a>.
                Values smaller than <code>1</code> (e.g. <code>0.5</code>) allow for greater granularity.
            </td>
        </tr>
        <tr id="map-trackresize">
            <td><code><b>trackResize</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether the map automatically handles browser window resize to update itself.</td>
        </tr>
        <tr id="map-boxzoom">
            <td><code><b>boxZoom</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether the map can be zoomed to a rectangular area specified by dragging
                the mouse while pressing the shift key.
            </td>
        </tr>
        <tr id="map-doubleclickzoom">
            <td><code><b>doubleClickZoom</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether the map can be zoomed in by double clicking on it and zoomed out by
                double clicking while holding shift. If passed <code>&#39;center&#39;</code>,
                double-click zoom will zoom to the center of the view regardless of where the mouse was.
            </td>
        </tr>
        <tr id="map-dragging">
            <td><code><b>dragging</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether the map be draggable with mouse/touch or not.</td>
        </tr>
        <tr id="map-geoclicker">
            <td><code><b>geoclicker</b></code></td>
            <td><code>Boolean | Object</code></td>
            <td><code>false</code></td>
            <td>
                <!-- TODO: translation -->
            </td>
        </tr>
        <tr id="map-projectdetector">
            <td><code><b>projectDetector</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code></td>
            <td>
                <!-- TODO: translation -->
            </td>
        </tr>
        <tr id="map-tilescheck">
            <td><code><b>tilesCheck</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>
                <!-- TODO: translation -->
            </td>
        </tr>
        <tr id="map-museum">
            <td><code><b>museum</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code></td>
            <td>Whether the message about unsupported browser will be displayed.</td>
        </tr>
    </tbody>
</table>

##### Map State Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-center">
            <td><code><b>center</b></code></td>
            <td><code>LatLng </code></td>
            <td><code>undefined</code></td>
            <td>Initial geographic center of the map</td>
        </tr>
        <tr id="map-zoom">
            <td><code><b>zoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>undefined</code></td>
            <td>Initial map zoom level</td>
        </tr>
        <tr id="map-minzoom">
            <td><code><b>minZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>undefined</code></td>
            <td>Minimum zoom level of the map. Overrides any <code>minZoom</code> option set on map layers.</td>
        </tr>
        <tr id="map-maxzoom">
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>undefined</code></td>
            <td>Maximum zoom level of the map. Overrides any <code>maxZoom</code> option set on map layers.</td>
        </tr>
        <tr id="map-layers">
            <td><code><b>layers</b></code></td>
            <td><code>Layer[] </code></td>
            <td><code>[]</code></td>
            <td>Array of layers that will be added to the map initially</td>
        </tr>
        <tr id="map-maxbounds">
            <td><code><b>maxBounds</b></code></td>
            <td><code>LatLngBounds </code></td>
            <td><code>null</code></td>
            <td>When this option is set, the map restricts the view to the given geographical bounds,
                bouncing the user back when he tries to pan outside the view. To set the restriction
                dynamically, use <a href="#map-setmaxbounds"><code>setMaxBounds</code></a> method.</td>
        </tr>
        <tr id="map-renderer">
            <td><code><b>renderer</b></code></td>
            <td><code>Renderer </code></td>
            <td><code>*</code></td>
            <td>The default method for drawing vector layers on the map.
                <a href="/doc/maps/en/manual/vector-layers#dgsvg"><code>DG.SVG</code></a>
                or <a href="/doc/maps/en/manual/vector-layers#dgcanvas"><code>DG.Canvas</code></a>
                by default depending on browser support.
            </td>
        </tr>
        <tr id="map-poi">
            <td><code><b>poi</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>
                <!-- TODO: translation -->
            </td>
        </tr>
        <tr id="map-currentlang">
            <td><code><b>currentLang</b></code></td>
            <td><code>string</code></td>
            <td><code>''</code></td>
            <td>Language of user interface (see <a href="/doc/maps/en/manual/dg-locale/">Localization</a>)</td>
        </tr>
    </tbody>
</table>

##### Animation Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-fadeanimation">
            <td><code><b>fadeAnimation</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether the tile fade animation is enabled. By default it&#39;s enabled
                in all browsers that support CSS3 Transitions except Android.
            </td>
        </tr>
        <tr id="map-markerzoomanimation">
            <td><code><b>markerZoomAnimation</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether markers animate their zoom with the zoom animation, if disabled they
                will disappear for the length of the animation. By default it&#39;s enabled
                in all browsers that support CSS3 Transitions except Android.
            </td>
        </tr>
        <tr id="map-transform3dlimit">
            <td><code><b>transform3DLimit</b></code></td>
            <td><code>Number </code></td>
            <td><code>2^23</code></td>
            <td>Defines the maximum size of a CSS translation transform. The default value should
                not be changed unless a web browser positions layers in the wrong place after doing
                a large <code>panBy</code>.
            </td>
        </tr>
        <tr id="map-zoomanimation">
            <td><code><b>zoomAnimation</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether the map zoom animation is enabled. By default it&#39;s enabled in all browsers
                that support CSS3 Transitions except Android.
            </td>
        </tr>
        <tr id="map-zoomanimationthreshold">
            <td><code><b>zoomAnimationThreshold</b></code></td>
            <td><code>Number </code></td>
            <td><code>4</code></td>
            <td>Won&#39;t animate zoom if the zoom difference exceeds this value.</td>
        </tr>
    </tbody>
</table>

##### Panning Inertia Options

<table>
    <thead>
	<tr>
		<th>Option</th>
		<th>Type</th>
		<th>Default</th>
		<th>Description</th>
	</tr>
	</thead>
    <tbody>
        <tr id="map-inertia">
            <td><code><b>inertia</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>*</code></td>
            <td>If enabled, panning of the map will have an inertia effect where the map builds
                momentum while dragging and continues moving in the same direction for some time.
                Feels especially nice on touch devices. Enabled by default unless running on old
                Android devices.
            </td>
        </tr>
        <tr id="map-inertiadeceleration">
            <td><code><b>inertiaDeceleration</b></code></td>
            <td><code>Number </code></td>
            <td><code>3000</code></td>
            <td>The rate with which the inertial movement slows down, in pixels/second².</td>
        </tr>
        <tr id="map-inertiamaxspeed">
            <td><code><b>inertiaMaxSpeed</b></code></td>
            <td><code>Number </code></td>
            <td><code>Infinity</code></td>
            <td>Max speed of the inertial movement, in pixels/second.</td>
        </tr>
        <tr id="map-easelinearity">
            <td><code><b>easeLinearity</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.2</code></td>
            <td></td>
        </tr>
        <tr id="map-worldcopyjump">
            <td><code><b>worldCopyJump</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>With this option enabled, the map tracks when you pan to another &quot;copy&quot;
                of the world and seamlessly jumps to the original one so that all overlays like
                markers and vector layers are still visible.
            </td>
        </tr>
        <tr id="map-maxboundsviscosity">
            <td><code><b>maxBoundsViscosity</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.0</code></td>
            <td>If <code>maxBounds</code> is set, this option will control how solid the bounds
                are when dragging the map around. The default value of <code>0.0</code> allows
                the user to drag outside the bounds at normal speed, higher values will slow down
                map dragging outside bounds, and <code>1.0</code> makes the bounds fully solid,
                preventing the user from dragging outside the bounds.
            </td>
        </tr>
    </tbody>
</table>

##### Keyboard Navigation Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-keyboard">
            <td><code><b>keyboard</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Makes the map focusable and allows users to navigate the map with keyboard
                arrows and <code>+</code>/<code>-</code> keys.
            </td>
        </tr>
        <tr id="map-keyboardpandelta">
            <td><code><b>keyboardPanDelta</b></code></td>
            <td><code>Number </code></td>
            <td><code>80</code></td>
            <td>Amount of pixels to pan when pressing an arrow key.</td>
        </tr>
    </tbody>
</table>

##### Mousewheel options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-scrollwheelzoom">
            <td><code><b>scrollWheelZoom</b></code></td>
            <td><code>Boolean | String</code></td>
            <td><code>true</code></td>
            <td>Whether the map can be zoomed by using the mouse wheel. If passed
                <code>&#39;center&#39;</code>, it will zoom to the center of the view
                regardless of where the mouse was.</td>
        </tr>
        <tr id="map-wheeldebouncetime">
            <td><code><b>wheelDebounceTime</b></code></td>
            <td><code>Number </code></td>
            <td><code>40</code></td>
            <td>Limits the rate at which a wheel can fire (in milliseconds). By default
                user can&#39;t zoom via wheel more often than once per 40 ms.
            </td>
        </tr>
        <tr id="map-wheelpxperzoomlevel">
            <td><code><b>wheelPxPerZoomLevel</b></code></td>
            <td><code>Number </code></td>
            <td><code>50</code></td>
            <td>How many scroll pixels (as reported by
                <a href="/doc/maps/en/manual/dom-utils#domevent-getwheeldelta>DG.DomEvent.getWheelDelta</a>)
                mean a change of one full zoom level. Smaller values will make wheel-zooming
                faster (and vice versa).
            </td>
        </tr>
    </tbody>
</table>

##### Touch interaction options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-tap">
            <td><code><b>tap</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Enables mobile hacks for supporting instant taps (fixing 200ms click
                delay on iOS/Android) and touch holds (fired as <code>contextmenu</code> events).
            </td>
        </tr>
        <tr id="map-taptolerance">
            <td><code><b>tapTolerance</b></code></td>
            <td><code>Number </code></td>
            <td><code>15</code></td>
            <td>The max number of pixels a user can shift his finger during touch
                for it to be considered a valid tap.
            </td>
        </tr>
        <tr id="map-touchzoom">
            <td><code><b>touchZoom</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>*</code></td>
            <td>Whether the map can be zoomed by touch-dragging with two fingers. If
                passed <code>&#39;center&#39;</code>, it will zoom to the center of the view regardless of
                where the touch events (fingers) were. Enabled for touch-capable web
                browsers except for old Androids.
            </td>
        </tr>
        <tr id="map-bounceatzoomlimits">
            <td><code><b>bounceAtZoomLimits</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Set it to false if you don&#39;t want the map to zoom beyond min/max zoom
                and then bounce back when pinch-zooming.
            </td>
        </tr>
    </tbody>
</table>

#### Events

##### Layer events

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-layeradd">
            <td><code><b>layeradd</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#layerevent">LayerEvent</a></code></td>
            <td>Fired when a new layer is added to the map.</td>
        </tr>
        <tr id="map-layerremove">
            <td><code><b>layerremove</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#layerevent">LayerEvent</a></code></td>
            <td>Fired when some layer is removed from the map</td>
        </tr>
    </tbody>
</table>

##### Map state change events

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-zoomlevelschange">
            <td><code><b>zoomlevelschange</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the number of zoomlevels on the map is changed due
                to adding or removing a layer.
            </td>
        </tr>
        <tr id="map-resize">
            <td><code><b>resize</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the map is resized.</td>
        </tr>
        <tr id="map-unload">
            <td><code><b>unload</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the map is destroyed with <a href="#map-remove">remove</a> method.</td>
        </tr>
        <tr id="map-viewreset">
            <td><code><b>viewreset</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the map needs to redraw its content (this usually happens
                on map zoom or load). Very useful for creating custom overlays.
            </td>
        </tr>
        <tr id="map-load">
            <td><code><b>load</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the map is initialized (when its center and zoom are set
                for the first time).
            </td>
        </tr>
        <tr id="map-zoomstart">
            <td><code><b>zoomstart</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the map zoom is about to change (e.g. before zoom animation).</td>
        </tr>
        <tr id="map-movestart">
            <td><code><b>movestart</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the view of the map starts changing (e.g. user starts dragging the map).</td>
        </tr>
        <tr id="map-zoom">
            <td><code><b>zoom</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired repeteadly during any change in zoom level, including zoom
                and fly animations.
            </td>
        </tr>
        <tr id="map-move">
            <td><code><b>move</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired repeteadly during any movement of the map, including pan and
                fly animations.
            </td>
        </tr>
        <tr id="map-zoomend">
            <td><code><b>zoomend</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the map has changed, after any animations.</td>
        </tr>
        <tr id="map-moveend">
            <td><code><b>moveend</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the center of the map stops changing (e.g. user stopped
                dragging the map).
            </td>
        </tr>
        <tr id="map-projectchange">
            <td><code><b>projectchange</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#projectevent">ProjectEvent</a></code></td>
            <td>
                <!-- TODO: translation -->
            </td>
        </tr>
        <tr id="map-projectleave">
            <td><code><b>projectleave</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#projectevent">ProjectEvent</a></code></td>
            <td>
                <!-- TODO: translation -->
            </td>
        </tr>
        <tr id="map-entranceshow">
            <td><code><b>entranceshow</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td><!-- TODO: translation --></td>
        </tr>
        <tr id="map-entrancehide">
            <td><code><b>entrancehide</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td><!-- TODO: translation --></td>
        </tr>
        <tr id="map-poihover">
            <td><code><b>poihover</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#poievent">MetaEvent</a></code></td>
            <td><!-- TODO: translation --></td>
        </tr>
        <tr id="map-poileave">
            <td><code><b>poileave</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#poievent">MetaEvent</a></code></td>
            <td><!-- TODO: translation --></td>
        </tr>
        <tr id="map-langchange">
            <td><code><b>langchange</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#langevent">LangEvent</a></code></td>
            <td><!-- TODO: translation --></td>
        </tr>
    </tbody>
</table>

##### Popup events

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-popupopen">
            <td><code><b>popupopen</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Fired when a popup is opened in the map</td>
        </tr>
        <tr id="map-popupclose">
            <td><code><b>popupclose</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Fired when a popup in the map is closed</td>
        </tr>
        <tr id="map-autopanstart">
            <td><code><b>autopanstart</b></code></td>
            <td><code></code></td>
            <td>Fired when the map starts autopanning when opening a popup.</td>
        </tr>
    </tbody>
</table>

##### Interaction events

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-click">
            <td><code><b>click</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the user clicks (or taps) the map.</td>
        </tr>
        <tr id="map-dblclick">
            <td><code><b>dblclick</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the user double-clicks (or double-taps) the map.</td>
        </tr>
        <tr id="map-mousedown">
            <td><code><b>mousedown</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the user pushes the mouse button on the map.</td>
        </tr>
        <tr id="map-mouseup">
            <td><code><b>mouseup</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the user releases the mouse button on the map.</td>
        </tr>
        <tr id="map-mouseover">
            <td><code><b>mouseover</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the mouse enters the map.</td>
        </tr>
        <tr id="map-mouseout">
            <td><code><b>mouseout</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the mouse leaves the map.</td>
        </tr>
        <tr id="map-mousemove">
            <td><code><b>mousemove</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired while the mouse moves over the map.</td>
        </tr>
        <tr id="map-contextmenu">
            <td><code><b>contextmenu</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the user pushes the right mouse button on the map, prevents
                default browser context menu from showing if there are listeners on
                this event. Also fired on mobile when the user holds a single touch
                for a second (also called long press).
            </td>
        </tr>
        <tr id="map-keypress">
            <td><code><b>keypress</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the user presses a key from the keyboard while the map is focused.</td>
        </tr>
        <tr id="map-preclick">
            <td><code><b>preclick</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired before mouse click on the map (sometimes useful when you
                want something to happen on click before any existing click
                handlers start running).
            </td>
        </tr>
    </tbody>
</table>

##### Animation Events

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-zoomanim">
            <td><code><b>zoomanim</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#zoomanimevent">ZoomAnimEvent</a></code></td>
            <td>Fired on every frame of a zoom animation</td>
        </tr>
    </tbody>
</table>

##### Location Events

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-locationerror">
            <td><code><b>locationerror</b></code></td>
            <td><code><a href="#errorevent">ErrorEvent</a></code></td>
            <td>Fired when geolocation (using the <a href="#map-locate"><code>locate</code></a> method) failed.</td>
        </tr>
        <tr id="map-locationfound">
            <td><code><b>locationfound</b></code></td>
            <td><code><a href="#locationevent">LocationEvent</a></code></td>
            <td>Fired when geolocation (using the <a href="#map-locate"><code>locate</code></a> method)
                went successfully.
            </td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-getrenderer">
            <td>
                <code>
                    <b>getRenderer</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/vector-layers#dgpath">Path</a>&gt; <i>layer</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/base-classes#dgrenderer">Renderer</a></code></td>
            <td>Returns the instance of
                <a href="/doc/maps/en/manual/base-classes#dgrenderer"><code>Renderer</code></a>
                that should be used to render the given
                <a href="/doc/maps/en/manual/vector-layers#dgpath"><code>Path</code></a>.
                It will ensure that the
                <a href="/doc/maps/en/manual/base-classes#dgrenderer"><code>renderer</code></a>
                options of the map and paths are respected, and that the renderers do exist on the map.
            </td>
        </tr>
    </tbody>
</table>

##### Methods for Layers and Controls

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-addlayer">
            <td>
                <code>
                    <b>addLayer</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Adds the given layer to the map</td>
        </tr>
        <tr id="map-removelayer">
            <td>
                <code>
                    <b>removeLayer</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Removes the given layer from the map.</td>
        </tr>
        <tr id="map-haslayer">
            <td>
                <code>
                    <b>hasLayer</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i>)</nobr>
                </code>
            </td>
            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the given layer is currently added to the map</td>
        </tr>
        <tr id="map-eachlayer">
            <td>
                <code>
                    <b>eachLayer</b>(
                    <nobr>&lt;Function&gt; <i>fn</i></nobr>,
                    <nobr>&lt;Object&gt; <i>context?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>
                Iterates over the layers of the map, optionally specifying context of the iterator function.
<pre><code>map.eachLayer(function(layer){
    layer.bindPopup(&#39;Hello&#39;);
});
</code></pre>
            </td>
        </tr>
        <tr id="map-openpopup">
            <td>
                <code>
                    <b>openPopup</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/popup#dgpopup">Popup</a>&gt; <i>popup</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Opens the specified popup while closing the previously opened (to make
                sure only one is opened at one time for usability).
            </td>
        </tr>
        <tr id="map-openpopup">
            <td>
                <code>
                    <b>openPopup</b>(
                    <nobr>&lt;String|HTMLElement&gt; <i>content</i></nobr>,
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;<a href="/doc/maps/en/manual/popup#popup-option">Popup options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Creates a popup with the specified content and options and opens
                it in the given point on a map.
            </td>
        </tr>
        <tr id="map-closepopup">
            <td>
                <code>
                    <b>closePopup</b>(<nobr>&lt;<a href="/doc/maps/en/manual/popup#dgpopup">Popup</a>&gt; <i>popup?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Closes the popup previously opened with <a href="#map-openpopup">openPopup</a>
                (or the given one).
            </td>
        </tr>
        <tr id="map-addcontrol">
            <td>
                <code>
                    <b>addControl</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/controls#dgcontrol">Control</a>&gt; <i>control</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Adds the given control to the map</td>
        </tr>
        <tr id="map-removecontrol">
            <td>
                <code>
                    <b>removeControl</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/controls#dgcontrol">Control</a>&gt; <i>control</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Removes the given control from the map</td>
        </tr>
    </tbody>
</table>

##### Methods for modifying map state

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-setview">
            <td>
                <code>
                    <b>setView</b>(
                    <nobr>&lt;LatLnt&gt; <i>center</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom</i></nobr>,
                    <nobr>&lt;Zoom/Pan options&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Sets the view of the map (geographical center and zoom) with the given
                animation options.
            </td>
        </tr>
        <tr id="map-setzoom">
            <td>
                <code>
                    <b>setZoom</b>(
                    <nobr>&lt;Number&gt; <i>zoom</i></nobr>,
                    <nobr>&lt;Zoom/Pan options&gt; <i>options</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Sets the zoom of the map.</td>
        </tr>
        <tr id="map-zoomin">
            <td>
                <code>
                    <b>zoomIn</b>(
                    <nobr>&lt;Number&gt; <i>delta?</i></nobr>,
                    <nobr>&lt;<a href="#zoom-options">Zoom options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Increases the zoom of the map by <code>delta</code>
                (<a href="#map-zoomdelta"><code>zoomDelta</code></a> by default).
            </td>
        </tr>
        <tr id="map-zoomout">
            <td>
                <code>
                    <b>zoomOut</b>(
                    <nobr>&lt;Number&gt; <i>delta?</i></nobr>,
                    <nobr>&lt;<a href="#zoom-options">Zoom options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Decreases the zoom of the map by <code>delta</code>
                (<a href="#map-zoomdelta"><code>zoomDelta</code></a> by default).
            </td>
        </tr>
        <tr id="map-setzoomaround">
            <td>
                <code>
                    <b>setZoomAround</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom</i></nobr>,
                    <nobr>&lt;<a href="#zoom-options">Zoom options</a>&gt; <i>options</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Zooms the map while keeping a specified geographical point on the map
                stationary (e.g. used internally for scroll zoom and double-click zoom).
            </td>
        </tr>
        <tr id="map-setzoomaround">
            <td>
                <code>
                    <b>setZoomAround</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>offset</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom</i></nobr>,
                    <nobr>&lt;<a href="#zoom-options">Zoom options</a>&gt; <i>options</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Zooms the map while keeping a specified pixel on the map
                (relative to the top-left corner) stationary.
            </td>
        </tr>
        <tr id="map-fitbounds">
            <td>
                <code>
                    <b>fitBounds</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>bounds</i></nobr>,
                    <nobr>&lt;<a href="#fitbounds-options">fitBounds options</a>&gt; <i>options</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Sets a map view that contains the given geographical bounds with the
                maximum zoom level possible.
            </td>
        </tr>
        <tr id="map-fitworld">
            <td>
                <code>
                    <b>fitWorld</b>(
                    <nobr>&lt;<a href="#fitbounds-options">fitBounds options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Sets a map view that mostly contains the whole world with the maximum
                zoom level possible.
            </td>
        </tr>
        <tr id="map-panto">
            <td>
                <code>
                    <b>panTo</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;<a href="#pan-options">Pan options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Pans the map to a given center.
            </td>
        </tr>
        <tr id="map-panby">
            <td>
                <code>
                    <b>panBy</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>offset</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Pans the map by a given number of pixels (animated).
            </td>
        </tr>
        <tr id="map-setmaxbounds">
            <td>
                <code>
                    <b>setMaxBounds</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgbounds">Bounds</a>&gt; <i>bounds</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Restricts the map view to the given bounds (see the
                <a href="#map-maxbounds">maxBounds</a> option).
            </td>
        </tr>
        <tr id="map-setminzoom">
            <td><code><b>setMinZoom</b>(<nobr>&lt;Number&gt; <i>zoom</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Sets the lower limit for the available zoom levels
                (see the <a href="#map-minzoom">minZoom</a> option).
            </td>
        </tr>
        <tr id="map-setmaxzoom">
            <td><code><b>setMaxZoom</b>(<nobr>&lt;Number&gt; <i>zoom</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Sets the upper limit for the available zoom levels
                (see the <a href="#map-maxzoom">maxZoom</a> option).
            </td>
        </tr>
        <tr id="map-paninsidebounds">
            <td>
                <code>
                    <b>panInsideBounds</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>bounds</i></nobr>,
                    <nobr>&lt;<a href="#pan-options">Pan options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Pans the map to the closest view that would lie inside the given bounds
                (if it&#39;s not already), controlling the animation using the options specific, if any.
            </td>
        </tr>
        <tr id="map-invalidatesize">
            <td><code><b>invalidateSize</b>(<nobr>&lt;Zoom/Pan options&gt; <i>options</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Checks if the map container size changed and updates the map if so —
                call it after you&#39;ve changed the map size dynamically, also animating
                pan by default. If <code>options.pan</code> is <code>false</code>, panning will not occur.
                If <code>options.debounceMoveend</code> is <code>true</code>, it will delay <code>moveend</code>
                event so that it doesn&#39;t happen often even if the method is called many
                times in a row.
            </td>
        </tr>
        <tr id="map-invalidatesize">
            <td><code><b>invalidateSize</b>(<nobr>&lt;Boolean&gt; <i>animate</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Checks if the map container size changed and updates the map if so —
                call it after you&#39;ve changed the map size dynamically, also animating
                pan by default.
            </td>
        </tr>
        <tr id="map-stop">
            <td><code><b>stop</b>()</code></td>
            <td><code>this</code></td>
            <td>Stops the currently running <code>panTo</code> or <code>flyTo</code> animation, if any.
            </td>
        </tr>
        <tr id="map-flyto">
            <td>
                <code>
                    <b>flyTo</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom?</i></nobr>,
                    <nobr>&lt;Zoom/Pan options&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Sets the view of the map (geographical center and zoom) performing a smooth
                pan-zoom animation.
            </td>
        </tr>
        <tr id="map-flytobounds">
            <td>
                <code>
                    <b>flyToBounds</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>bounds</i></nobr>,
                    <nobr>&lt;<a href="#fitbounds-options">fitBounds options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Sets the view of the map with a smooth animation like
                <a href="#map-flyto"><code>flyTo</code></a>,
                but takes a bounds parameter like <a href="#map-fitbounds"><code>fitBounds</code></a>.
            </td>
        </tr>
        <tr id="map-setlang">
            <td><code><b>setLang</b>( <nobr>&lt;String&gt; <i>lang</i> )</nobr></code></td>
            <td><code>String</code></td>
            <td>
                <!-- TODO: translation -->
            </td>
        </tr>
    </tbody>
</table>

##### Other Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-addhandler">
            <td>
                <code>
                    <b>addHandler</b>(
                    <nobr>&lt;String&gt; <i>name</i></nobr>,
                    <nobr>&lt;Function&gt; <i>HandlerClass</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Adds a new <a href="/doc/maps/en/manual/base-classes#dghandler"><code>Handler</code></a> to the map,
                given its name and constructor function.
            </td>
        </tr>
        <tr id="map-remove">
            <td><code><b>remove</b>()</code></td>
            <td><code>this</code></td>
            <td>Destroys the map and clears all related event listeners.
        </td>
        </tr>
        <tr id="map-createpane">
            <td>
                <code>
                    <b>createPane</b>(
                    <nobr>&lt;String&gt; <i>name</i></nobr>,
                    <nobr>&lt;HTMLElement&gt; <i>container?</i>)</nobr>
                </code>
            </td>
            <td><code>HTMLElement</code></td>
            <td>Creates a new map pane with the given name if it doesn&#39;t exist already,
                then returns it. The pane is created as a children of <code>container</code>, or
                as a children of the main map pane if not set.
            </td>
        </tr>
        <tr id="map-getpane">
            <td><code><b>getPane</b>(<nobr>&lt;String|HTMLElement&gt; <i>pane</i>)</nobr></code></td>
            <td><code>HTMLElement</code></td>
            <td>Returns a map pane, given its name or its HTML element (its identity).</td>
        </tr>
        <tr id="map-getpanes">
            <td><code><b>getPanes</b>()</code></td>
            <td><code>Object</code></td>
            <td>Returns a plain object containing the names of all panes as keys and
                the panes as values.
            </td>
        </tr>
        <tr id="map-getcontainer">
            <td><code><b>getContainer</b>()</code></td>
            <td><code>HTMLElement</code></td>
            <td>Returns the HTML element that contains the map.</td>
        </tr>
        <tr id="map-whenready">
            <td>
                <code>
                    <b>whenReady</b>(
                    <nobr>&lt;Function&gt; <i>fn</i></nobr>,
                    <nobr>&lt;Object&gt; <i>context?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Runs the given function <code>fn</code> when the map gets initialized with
                a view (center and zoom) and at least one layer, or immediately
                if it&#39;s already initialized, optionally passing a function context.
            </td>
        </tr>
    </tbody>
</table>

##### Methods for Getting Map State

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-getcenter">
            <td><code><b>getCenter</b>()</code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Returns the geographical center of the map view</td>
        </tr>
        <tr id="map-getzoom">
            <td><code><b>getZoom</b>()</code></td>
            <td><code>Number</code></td>
            <td>Returns the current zoom level of the map view</td>
        </tr>
        <tr id="map-getbounds">
            <td><code><b>getBounds</b>()</code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlngbounds">LatLngBounds</a></code></td>
            <td>Returns the geographical bounds visible in the current map view</td>
        </tr>
        <tr id="map-getminzoom">
            <td><code><b>getMinZoom</b>()</code></td>
            <td><code>Number</code></td>
            <td>Returns the minimum zoom level of the map (if set in the <code>minZoom</code>
                option of the map or of any layers), or <code>0</code> by default.
            </td>
        </tr>
        <tr id="map-getmaxzoom">
            <td><code><b>getMaxZoom</b>()</code></td>
            <td><code>Number</code></td>
            <td>Returns the maximum zoom level of the map (if set in the <code>maxZoom</code>
                option of the map or of any layers).
            </td>
        </tr>
        <tr id="map-getboundszoom">
            <td>
                <code>
                    <b>getBoundsZoom</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>bounds</i></nobr>,
                    <nobr>&lt;Boolean&gt; <i>inside?</i>)</nobr>
                </code>
            </td>
            <td><code>Number</code></td>
            <td>Returns the maximum zoom level on which the given bounds fit to the map
                view in its entirety. If <code>inside</code> (optional) is set to <code>true</code>, the method
                instead returns the minimum zoom level on which the map view fits into
                the given bounds in its entirety.
            </td>
        </tr>
        <tr id="map-getsize">
            <td><code><b>getSize</b>()</code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Returns the current size of the map container (in pixels).</td>
        </tr>
        <tr id="map-getpixelbounds">
            <td><code><b>getPixelBounds</b>()</code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgbounds">Bounds</a></code></td>
            <td>Returns the bounds of the current map view in projected pixel
                coordinates (sometimes useful in layer and overlay implementations).
            </td>
        </tr>
        <tr id="map-getpixelorigin">
            <td><code><b>getPixelOrigin</b>()</code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Returns the projected pixel coordinates of the top left point of
                the map layer (useful in custom layer and overlay implementations).
            </td>
        </tr>
        <tr id="map-getpixelworldbounds">
            <td>
                <code>
                    <b>getPixelWorldBounds</b>(
                    <nobr>&lt;Number&gt; <i>zoom?</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgbounds">Bounds</a></code></td>
            <td>Returns the world&#39;s bounds in pixel coordinates for zoom level <code>zoom</code>.
                If <code>zoom</code> is omitted, the map&#39;s current zoom level is used.
            </td>
        </tr>
        <tr id="map-getlang">
            <td><code><b>getLang</b>()</code></td>
            <td><code>String</code></td>
            <td><!-- TODO: translation --></td>
        </tr>
    </tbody>
</table>

##### Conversion Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-getzoomscale">
            <td>
                <code>
                    <b>getZoomScale</b>(
                    <nobr>&lt;Number&gt; <i>toZoom</i></nobr>,
                    <nobr>&lt;Number&gt; <i>fromZoom</i>)</nobr>
                </code>
            </td>
            <td><code>Number</code></td>
            <td>Returns the scale factor to be applied to a map transition from zoom level
                <code>fromZoom</code> to <code>toZoom</code>. Used internally to help with zoom animations.
            </td>
        </tr>
        <tr id="map-getscalezoom">
            <td>
                <code><b>getScaleZoom</b>(
                <nobr>&lt;Number&gt; <i>scale</i></nobr>,
                <nobr>&lt;Number&gt; <i>fromZoom</i>)</nobr>
                </code>
            </td>
            <td><code>Number</code></td>
            <td>Returns the zoom level that the map would end up at, if it is at <code>fromZoom</code>
                level and everything is scaled by a factor of <code>scale</code>. Inverse of
                <a href="#map-getZoomScale"><code>getZoomScale</code></a>.
            </td>
        </tr>
        <tr id="map-project">
            <td>
                <code>
                    <b>project</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Projects a geographical coordinate <a href="/doc/maps/en/manual/basic-types#dglatlng"><code>LatLng</code></a>
                according to the projection of the map&#39;s CRS, then scales it according to
                <code>zoom</code> and the CRS&#39;s
                <a href="#transformation"><code>Transformation</code></a>. The result is pixel coordinate relative to
                the CRS origin.
            </td>
        </tr>
        <tr id="map-unproject">
            <td>
                <code>
                    <b>unproject</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Inverse of <a href="#map-project"><code>project</code></a>.
            </td>
        </tr>
        <tr id="map-layerpointtolatlng">
            <td>
                <code>
                    <b>layerPointToLatLng</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Given a pixel coordinate relative to the <a href="#map-getpixelorigin">origin pixel</a>,
                returns the corresponding geographical coordinate (for the current zoom level).
            </td>
        </tr>
        <tr id="map-latlngtolayerpoint">
            <td>
                <code>
                    <b>latLngToLayerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Given a geographical coordinate, returns the corresponding pixel coordinate
                relative to the <a href="#map-getpixelorigin">origin pixel</a>.
            </td>
        </tr>
        <tr id="map-wraplatlng">
            <td>
                <code>
                    <b>wrapLatLng</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Returns a <a href="/doc/maps/en/manual/basic-types#dglatlng"><code>LatLng</code></a> where <code>lat</code>
                and <code>lng</code> has been wrapped according to the
                map&#39;s CRS&#39;s <code>wrapLat</code> and <code>wrapLng</code> properties, if they are outside the
                CRS&#39;s bounds.
                By default this means longitude is wrapped around the dateline so its
                value is between -180 and +180 degrees.
            </td>
        </tr>
        <tr id="map-distance">
            <td>
                <code>
                    <b>distance</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng1</i></nobr>,
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng2</i>)</nobr>
                </code>
            </td>
            <td><code>Number</code></td>
            <td>Returns the distance between two geographical coordinates according to
                the map&#39;s CRS. By default this measures distance in meters.
            </td>
        </tr>
        <tr id="map-containerpointtolayerpoint">
            <td>
                <code>
                    <b>containerPointToLayerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Given a pixel coordinate relative to the map container, returns the corresponding
                pixel coordinate relative to the <a href="#map-getpixelorigin">origin pixel</a>.
            </td>
        </tr>
        <tr id="map-layerpointtocontainerpoint">
            <td>
                <code>
                    <b>layerPointToContainerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Given a pixel coordinate relative to the <a href="#map-getpixelorigin">origin pixel</a>,
                returns the corresponding pixel coordinate relative to the map container.
            </td>
        </tr>
        <tr id="map-containerpointtolatlng">
            <td>
                <code>
                    <b>containerPointToLatLng</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Given a pixel coordinate relative to the map container, returns
                the corresponding geographical coordinate (for the current zoom level).
            </td>
        </tr>
        <tr id="map-latlngtocontainerpoint">
            <td>
                <code>
                    <b>latLngToContainerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Given a geographical coordinate, returns the corresponding pixel coordinate
                relative to the map container.
            </td>
        </tr>
        <tr id="map-mouseeventtocontainerpoint">
            <td>
                <code>
                    <b>mouseEventToContainerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a>&gt; <i>ev</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Given a MouseEvent object, returns the pixel coordinate relative to the
                map container where the event took place.
            </td>
        </tr>
        <tr id="map-mouseeventtolayerpoint">
            <td>
                <code>
                    <b>mouseEventToLayerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a>&gt; <i>ev</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Given a MouseEvent object, returns the pixel coordinate relative to
                the <a href="#map-getpixelorigin">origin pixel</a> where the event took place.
            </td>
        </tr>
        <tr id="map-mouseeventtolatlng">
            <td>
                <code>
                    <b>mouseEventToLatLng</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a>&gt; <i>ev</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Given a MouseEvent object, returns geographical coordinate where the
                event took place.
            </td>
        </tr>
    </tbody>
</table>

##### Geolocation methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead
    ><tbody>
        <tr id="map-locate">
            <td>
                <code>
                    <b>locate</b>(
                    <nobr>&lt;<a href="#locate-options">Locate options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Tries to locate the user using the Geolocation API, firing a <code>locationfound</code>
                event with location data on success or a <code>locationerror</code> event on failure,
                and optionally sets the map view to the user&#39;s location with respect to
                detection accuracy (or to the world view if geolocation failed).
                See <a href="#locate-options"><code>Locate options</code></a> for more details.
            </td>
        </tr>
        <tr id="map-stoplocate">
            <td><code><b>stopLocate</b>()</code></td>
            <td><code>this</code></td>
            <td>Stops watching location previously initiated by <code>map.locate({watch: true})</code>
                and aborts resetting the map view if map.locate was called with
                <code>{setView: true}</code>.
            </td>
        </tr>
    </tbody>
</table>

##### Methods inherited from Evented

Methods inherited from Evented see <a href="/doc/maps/en/manual/base-classes#dgevented-methods">here</a>.

### Properties

<!-- TODO: translation -->

#### Handlers

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-boxzoom">
            <td><code><b>boxZoom</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Box (shift-drag with mouse) zoom handler.</td>
        </tr>
        <tr id="map-doubleclickzoom">
            <td><code><b>doubleClickZoom</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Double click zoom handler.</td>
        </tr>
        <tr id="map-dragging">
            <td><code><b>dragging</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Map dragging handler (by both mouse and touch).</td>
        </tr>
        <tr id="map-keyboard">
            <td><code><b>keyboard</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Keyboard navigation handler.</td>
        </tr>
        <tr id="map-scrollwheelzoom">
            <td><code><b>scrollWheelZoom</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Scroll wheel zoom handler.</td>
        </tr>
        <tr id="map-tap">
            <td><code><b>tap</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Mobile touch hacks (quick tap and touch hold) handler.</td>
        </tr>
        <tr id="map-touchzoom">
            <td><code><b>touchZoom</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Touch zoom handler.</td>
        </tr>
        <tr id="map-geoclicker">
            <td><code><b>geoclicker</b></code></td>
            <td><a href="/doc/maps/en/manual/base-classes#dghandler"><code>Handler</code></a></td>
            <td><!-- TODO: translation --></td>
        </tr>
        <tr id="map-projectDetector">
            <td><code><b>projectDetector</b></code></td>
            <td><a href="/doc/maps/en/manual/base-classes#dghandler"><code>Handler</code></a></td>
            <td><!-- TODO: translation --></td>
        </tr>
        <tr id="map-zoomControl">
            <td><code><b>zoomControl</b></code></td>
            <td><a href="/doc/maps/en/manual/controls#dgcontrol.zoom"><code>Control.Zoom</code></a></td>
            <td><!-- TODO: translation --></td>
        </tr>
        <tr id="map-fullscreenControl">
            <td><code><b>fullscreenControl</b></code></td>
            <td><a href="/doc/maps/en/manual/controls#dgcontrol.fullscreen"><code>Control.FullScreen</code></a></td>
            <td><!-- TODO: translation --></td>
        </tr>
        <tr id="map-rulerControl">
            <td><code><b>rulerControl</b></code></td>
            <td><a href="/doc/maps/en/manual/controls#dgcontrol.ruler"><code>Control.Ruler</code></a></td>
            <td><!-- TODO: translation --></td>
        </tr>
        <tr id="map-trafficControl">
            <td><code><b>trafficControl</b></code></td>
            <td><a href="/doc/maps/en/manual/controls#dgcontrol.traffic"><code>Control.Traffic</code></a></td>
            <td><!-- TODO: translation --></td>
        </tr>
        <tr id="map-baseLayer">
            <td><code><b>baseLayer</b></code></td>
            <td><a href="/doc/maps/en/manual/raster-layers#dgtilelayer"><code>TileLayer</code></a></td>
            <td><!-- TODO: translation --></td>
        </tr>
    </tbody>
</table>

#### Map panes

Panes are DOM elements used to control the ordering of layers on the map. You
can access panes with <a href="#map-getpane"><code>map.getPane</code></a> or
<a href="#map-getpanes"><code>map.getPanes</code></a> methods. New panes can be created with the
<a href="#map-createpane"><code>map.createPane</code></a> method.
Every map has the following default panes that differ only in zIndex.

<table>
    <thead>
        <tr>
            <th>Pane</th>
            <th>Type</th>
            <th>Z-index</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-mappane">
            <td><code><b>mapPane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>&#x27;auto&#x27;</code></td>
            <td>Pane that contains all other map panes</td>
        </tr>
        <tr id="map-tilepane">
            <td><code><b>tilePane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>2</code></td>
            <td>Pane for tile layers</td>
        </tr>
        <tr id="map-overlaypane">
            <td><code><b>overlayPane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>4</code></td>
            <td>Pane for overlays like polylines and polygons</td>
        </tr>
        <tr id="map-shadowpane">
            <td><code><b>shadowPane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>5</code></td>
            <td>Pane for overlay shadows (e.g. marker shadows)</td>
        </tr>
        <tr id="map-markerpane">
            <td><code><b>markerPane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>6</code></td>
            <td>Pane for marker icons</td>
        </tr>
        <tr id="map-popuppane">
            <td><code><b>popupPane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>7</code></td>
            <td>Pane for popups.</td>
        </tr>
    </tbody>
</table>

#### Locate options

Some of the geolocation methods for <a href="#dgmap"><code>Map</code></a> take in an <code>options</code> parameter.
This is a plain javascript object with the following optional components:

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="locate-options-watch">
            <td><code><b>watch</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If <code>true</code>, starts continous watching of location changes (instead of detecting it
                once) using W3C <code>watchPosition</code> method. You can later stop watching using
                <code>map.stopLocate()</code> method.
            </td>
        </tr>
        <tr id="locate-options-setview">
            <td><code><b>setView</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If <code>true</code>, automatically sets the map view to the user location with respect to
                detection accuracy, or to world view if geolocation failed.
            </td>
        </tr>
        <tr id="locate-options-maxzoom">
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>Infinity</code></td>
            <td>The maximum zoom for automatic view setting when using <code>setView</code> option.</td>
        </tr>
        <tr id="locate-options-timeout">
            <td><code><b>timeout</b></code></td>
            <td><code>Number </code></td>
            <td><code>10000</code></td>
            <td>Number of milliseconds to wait for a response from geolocation before firing a
                <code>locationerror</code> event.
            </td>
        </tr>
        <tr id="locate-options-maximumage">
            <td><code><b>maximumAge</b></code></td>
            <td><code>Number </code></td>
            <td><code>0</code></td>
            <td>Maximum age of detected location. If less than this amount of milliseconds
                passed since last geolocation response, <code>locate</code> will return a cached location.
            </td>
        </tr>
        <tr id="locate-options-enablehighaccuracy">
            <td><code><b>enableHighAccuracy</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Enables high accuracy, see
                <a href="http://dev.w3.org/geo/api/spec-source.html#high-accuracy">description in the W3C spec</a>.
            </td>
        </tr>
    </tbody>
</table>


#### Zoom options

Some of the <a href="#dgmap"><code>Map</code></a> methods which modify the zoom level take in an <code>options</code>
parameter. This is a plain javascript object with the following optional
components:

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="zoom-options-animate">
            <td><code><b>animate</b></code></td>
            <td><code>Boolean</code></td>
            <td><code></code></td>
            <td>If not specified, zoom animation will happen if the zoom origin is inside the
                current view. If <code>true</code>, the map will attempt animating zoom disregarding where
                zoom origin is. Setting <code>false</code> will make it always reset the view completely
                without animation.
            </td>
        </tr>
    </tbody>
</table>

#### Pan options

Some of the <a href="#map"><code>Map</code></a> methods which modify the center of the map take in an
<code>options</code> parameter. This is a plain javascript object with the following optional components:

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="pan-options-animate">
            <td><code><b>animate</b></code></td>
            <td><code>Boolean</code></td>
            <td><code></code></td>
            <td>If <code>true</code>, panning will always be animated if possible. If <code>false</code>, it will
                not animate panning, either resetting the map view if panning more than a
                screen away, or just setting a new offset for the map pane (except for <code>panBy</code>
                which always does the latter).
            </td>
        </tr>
        <tr id="pan-options-duration">
            <td><code><b>duration</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.25</code></td>
            <td>Duration of animated panning, in seconds.</td>
        </tr>
        <tr id="pan-options-easelinearity">
            <td><code><b>easeLinearity</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.25</code></td>
            <td>The curvature factor of panning animation easing (third parameter of the
                <a href="http://cubic-bezier.com/">Cubic Bezier curve</a>). 1.0 means linear animation,
                the less the more bowed the curve.
            </td>
        </tr>
        <tr id="pan-options-nomovestart">
            <td><code><b>noMoveStart</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If <code>true</code>, panning won&#39;t fire <code>movestart</code> event on
                start (used internally for panning inertia).
            </td>
        </tr>
    </tbody>
</table>

#### Zoom/pan options

Options inherited from <a href="#zoom-options">Zoom options</a>

Options inherited from <a href="#pan-options">Pan options</a>

#### FitBounds options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
	<tr id="fitbounds-options-paddingtopleft">
		<td><code><b>paddingTopLeft</b></code></td>
		<td><code>Point </code></td>
		<td><code>[0, 0]</code></td>
		<td>Sets the amount of padding in the top left corner of a map container that
            shouldn&#39;t be accounted for when setting the view to fit bounds. Useful if you
            have some control overlays on the map like a sidebar and you don&#39;t want them
            to obscure objects you&#39;re zooming to.
        </td>
        </tr>
        <tr id="fitbounds-options-paddingbottomright">
            <td><code><b>paddingBottomRight</b></code></td>
            <td><code>Point </code></td>
            <td><code>[0, 0]</code></td>
            <td>The same for the bottom right corner of the map.</td>
        </tr>
        <tr id="fitbounds-options-padding">
            <td><code><b>padding</b></code></td>
            <td><code>Point </code></td>
            <td><code>[0, 0]</code></td>
            <td>Equivalent of setting both top left and bottom right padding to the same value.</td>
        </tr>
        <tr id="fitbounds-options-maxzoom">
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>null</code></td>
            <td>The maximum possible zoom to use.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/en/manual/markers.md
================================================
## Markers

{toc}

### DG.Marker

DG.Marker is used to display clickable/draggable icons on the map.

	DG.marker([54.98, 82.89]).addTo(map);

#### Creation

<table>
	<thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
		<tr>
			<td><code><b>DG.Marker</b>(
				<nobr>&lt;<a href="/doc/maps/en/manual/base-types#dglatlng">LatLng</a>&gt; <i>latlng</i>,</nobr>
				<nobr>&lt;<a href="#options">Marker options</a>&gt; <i>options?</i> )</nobr>
			</code></td>
			<td>Instantiates a Marker object given a geographical point and optionally an options object.</td>
		</tr>
	</tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-icon">
            <td><code><b>icon</b></code></td>
            <td><code><a href="#dgicon">Icon</a></code></td>
            <td><code>*</code></td>
            <td>Icon class to use for rendering the marker. See <a href="#dgicon">Icon documentation</a>
                for details on how to customize the marker icon. Set to new
                <code>DG.Icon.Default()</code> by default.</td>
        </tr>
        <tr id="marker-interactive">
            <td><code><b>interactive</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>If <code>false</code>, the marker will not emit mouse events and will act as a part of
                the underlying map.</td>
        </tr>
        <tr id="marker-draggable">
            <td><code><b>draggable</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Whether the marker is draggable with mouse/touch or not.</td>
        </tr>
        <tr id="marker-keyboard">
            <td><code><b>keyboard</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether the marker can be tabbed to with a keyboard and clicked by pressing enter.</td>
        </tr>
        <tr id="marker-title">
            <td><code><b>title</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>Text for the browser tooltip that appear on marker hover (no tooltip by default).</td>
        </tr>
        <tr id="marker-alt">
            <td><code><b>alt</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>Text for the <code>alt</code> attribute of the icon image (useful for accessibility).</td>
        </tr>
        <tr id="marker-zindexoffset">
            <td><code><b>zIndexOffset</b></code></td>
            <td><code>Number </code></td>
            <td><code>0</code></td>
            <td>By default, marker images zIndex is set automatically based on its latitude.
                Use this option if you want to put the marker on top of all others (or below),
                specifying a high value like <code>1000</code> (or high negative value, respectively).</td>
        </tr>
        <tr id="marker-opacity">
            <td><code><b>opacity</b></code></td>
            <td><code>Number </code></td>
            <td><code>1.0</code></td>
            <td>The opacity of the marker.</td>
        </tr>
        <tr id="marker-riseonhover">
            <td><code><b>riseOnHover</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If <code>true</code>, the marker will get on top of others when you hover the mouse over it.</td>
        </tr>
        <tr id="marker-riseoffset">
            <td><code><b>riseOffset</b></code></td>
            <td><code>Number </code></td>
            <td><code>250</code></td>
            <td>The z-index offset used for the <code>riseOnHover</code> feature.</td>
        </tr>
        <tr id="marker-pane">
            <td><code><b>pane</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;markerPane&#x27;</code></td>
            <td><code>Map pane</code> where the markers icon will be added.</td>
        </tr>
    </tbody>
</table>

#### Events

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-click">
            <td><code><b>click</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the user clicks (or taps) the marker.</td>
        </tr>
        <tr id="marker-dblclick">
            <td><code><b>dblclick</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the user double-clicks (or double-taps) the marker.</td>
        </tr>
        <tr id="marker-mousedown">
            <td><code><b>mousedown</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the user pushes the mouse button on the marker.</td>
        </tr>
        <tr id="marker-mouseover">
            <td><code><b>mouseover</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the mouse enters the marker.</td>
        </tr>
        <tr id="marker-mouseout">
            <td><code><b>mouseout</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the mouse leaves the marker.</td>
        </tr>
        <tr id="marker-contextmenu">
            <td><code><b>contextmenu</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Fired when the user right-clicks on the marker.</td>
        </tr>
        <tr id="marker-move">
            <td><code><b>move</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the marker is moved via <a href="#marker-setlatlng"><code>setLatLng</code></a>
                or by <a href="#marker-dragging">dragging</a>. Old and new coordinates are included in
                event arguments as <code>oldLatLng</code>, <a href="/doc/maps/en/manual/basic-types#dglatlng"><code>latlng</code></a>.</td>
        </tr>
    </tbody>
</table>

##### Dragging events

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-dragstart">
            <td><code><b>dragstart</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the user starts dragging the marker.</td>
        </tr>
        <tr id="marker-movestart">
            <td><code><b>movestart</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the marker starts moving (because of dragging).</td>
        </tr>
        <tr id="marker-drag">
            <td><code><b>drag</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired repeatedly while the user drags the marker.</td>
        </tr>
        <tr id="marker-dragend">
            <td><code><b>dragend</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#dragendevent">DragEndEvent</a></code></td>
            <td>Fired when the user stops dragging the marker.</td>
        </tr>
        <tr id="marker-moveend">
            <td><code><b>moveend</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the marker stops moving (because of dragging).</td>
        </tr>
    </tbody>
</table>

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-add">
            <td><code><b>add</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired after the layer is added to a map</td>
        </tr>
        <tr id="marker-remove">
            <td><code><b>remove</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired after the layer is removed from a map</td>
        </tr>
    </tbody>
</table>

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-popupopen">
            <td><code><b>popupopen</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Fired when a popup bound to this layer is opened</td>
        </tr>
        <tr id="marker-popupclose">
            <td><code><b>popupclose</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Fired when a popup bound to this layer is closed</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-getlatlng">
            <td><code><b>getLatLng</b>()</nobr></code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Returns the current geographical position of the marker.</td>
        </tr>
        <tr id="marker-setlatlng">
            <td><code><b>setLatLng</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr>
                </code></td>
            <td><code>this</code></td>
            <td>Changes the marker position to the given point.</td>
        </tr>
        <tr id="marker-setzindexoffset">
            <td><code><b>setZIndexOffset</b>(
                    <nobr>&lt;Number&gt; <i>offset</i>)</nobr>
                </code></td>
            <td><code>this</code></td>
            <td>Changes the <a href="#marker-zindexoffset">zIndex offset</a> of the marker.</td>
        </tr>
        <tr id="marker-seticon">
            <td><code><b>setIcon</b>(
                    <nobr>&lt;<a href="#dgicon">Icon</a>&gt; <i>icon</i>)</nobr>
                </code></td>
            <td><code>this</code></td>
            <td>Changes the marker icon.</td>
        </tr>
        <tr id="marker-setopacity">
            <td><code><b>setOpacity</b>(
                    <nobr>&lt;Number&gt; <i>opacity</i>)</nobr>
                </code></td>
            <td><code>this</code></td>
            <td>Changes the opacity of the marker. </td>
        </tr>
	    <tr id="marker-bindlabel">
	        <td><code><b>bindLabel</b>(&lt;String&gt; content, &lt;<a href="/doc/maps/en/manual/dg-label#опции">Label options</a>&gt; options?)</code></td>
            <td><code>this</code></td>
            <td><!-- TODO: translate --></td>
	    </tr>
	    <tr id="marker-unbindlabel">
	        <td><code><b>unbindLabel</b>()</code></td>
	        <td><code>this</code></td>
            <td><!-- TODO: translate --></td>
	    </tr>
	    <tr id="marker-showLabel">
	        <td><code><b>showLabel</b>()</code></td>
	        <td><code>this</code></td>
            <td><!-- TODO: translate --></td>
	    </tr>
	    <tr id="marker-hideLabel">
	        <td><code><b>hideLabel</b>()</code></td>
	        <td><code>this</code></td>
            <td><!-- TODO: translate --></td>
	    </tr>
    </tbody>
</table>

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

#### Interaction handlers

Interaction handlers are properties of a marker instance that allow you to control interaction
behavior in runtime, enabling or disabling certain features such as dragging
(see Handler methods). Example: 

	marker.dragging.disable();

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-dragging">
            <td><code><b>dragging</b></code></td>
            <td><code><a href="/doc/maps/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Marker dragging handler (by both mouse and touch).</td>
        </tr>
    </tbody>
</table>

### DG.Icon

Represents an icon to provide when creating a marker.

    var myIcon = DG.icon({
        iconUrl: 'my-icon.png',
        iconRetinaUrl: 'my-icon@2x.png',
        iconSize: [38, 95],
        iconAnchor: [22, 94],
        popupAnchor: [-3, -76],
        shadowUrl: 'my-icon-shadow.png',
        shadowRetinaUrl: 'my-icon-shadow@2x.png',
        shadowSize: [68, 95],
        shadowAnchor: [22, 94]
    });

    DG.marker([50.505, 30.57], {icon: myIcon}).addTo(map);

#### Creation

<table>
	<thead>
	    <tr>
	        <th>Factory</th>
	        <th>Description</th>
	    </tr>
	</thead>
	<tbody>
	    <tr>
            <td><code><b>DG.icon</b>(
                <nobr>&lt;<a href="#icon-option">Icon options</a>&gt; <i>options</i>)</nobr>
            </code></td>
            <td>Creates an icon instance with the given options.</td>
	    </tr>
	</tbody>
</table>

#### Options

<table id="dgicon-options">
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="icon-iconurl">
            <td><code><b>iconUrl</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
            <td><strong>(required)</strong> The URL to the icon image (absolute or relative to your script path).</td>
        </tr>
        <tr id="icon-iconretinaurl">
            <td><code><b>iconRetinaUrl</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
            <td>The URL to a retina sized version of the icon image (absolute or relative to your
                script path). Used for Retina screen devices.</td>
        </tr>
        <tr id="icon-iconsize">
            <td><code><b>iconSize</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
            <td>Size of the icon image in pixels.</td>
        </tr>
        <tr id="icon-iconanchor">
            <td><code><b>iconAnchor</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
            <td>The coordinates of the &quot;tip&quot; of the icon (relative to its top left corner). The icon
                will be aligned so that this point is at the marker&#39;s geographical location. Centered
                by default if size is specified, also can be set in CSS with negative margins.</td>
        </tr>
        <tr id="icon-popupanchor">
            <td><code><b>popupAnchor</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
            <td>The coordinates of the point from which popups will &quot;open&quot;, relative to the icon anchor.</td>
        </tr>
        <tr id="icon-shadowurl">
            <td><code><b>shadowUrl</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
            <td>The URL to the icon shadow image. If not specified, no shadow image will be created.</td>
        </tr>
        <tr id="icon-shadowretinaurl">
            <td><code><b>shadowRetinaUrl</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
            <td></td>
        </tr>
        <tr id="icon-shadowsize">
            <td><code><b>shadowSize</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
            <td>Size of the shadow image in pixels.</td>
        </tr>
        <tr id="icon-shadowanchor">
            <td><code><b>shadowAnchor</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
            <td>The coordinates of the &quot;tip&quot; of the shadow (relative to its top left corner) (the same
                as iconAnchor if not specified).</td>
        </tr>
        <tr id="icon-classname">
            <td><code><b>className</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>A custom class name to assign to both icon and shadow images. Empty by default.</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Methods

<table id="dgicon-methods">
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="icon-createicon">
            <td><code><b>createIcon</b>(<nobr>&lt;HTMLElement&gt; <i>oldIcon?</i>)</nobr></code></td>
            <td><code>HTMLElement</code></td>
            <td>Called internally when the icon has to be shown,
                returns a <code>&lt;img&gt;</code> HTML element
                styled according to the options.</td>
        </tr>
        <tr id="icon-createshadow">
            <td><code><b>createShadow</b>(<nobr>&lt;HTMLElement&gt; <i>oldIcon?</i>)</nobr></code></td>
            <td><code>HTMLElement</code></td>
            <td>As <code>createIcon</code>, but for the shadow beneath it.</td>
        </tr>
    </tbody>
</table>

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.DivIcon

Represents a lightweight icon for markers that uses a simple <code>&lt;div&gt;</code>
element instead of an image. Inherits from <a href="#dgicon"><code>Icon</code></a>
but ignores the <code>iconUrl</code> and shadow options.

    // you can set .my-div-icon styles in CSS
    var myIcon = DG.divIcon({className: 'my-div-icon'}); 

    DG.marker([50.505, 30.57], {icon: myIcon}).addTo(map);

#### Creation

<table>
	<thead>
	    <tr>
	        <th>Factory</th>
	        <th>Description</th>
	    </tr>
	</thead>
	<tbody>
	    <tr>
	        <td><code><b>DG.DivIcon</b>(
	            <nobr>&lt;<a href="#divicon-options">DivIcon options</a>&gt; <i>options</i> )</nobr>
	        </code></td>
            <td>Creates a <code>DivIcon</code> instance with the given options.</td>
	    </tr>
	</tbody>
</table>

#### Options

<table>
	<thead>
	    <tr>
	        <th>Option</th>
	        <th>Type</th>
	        <th>Default</th>
	        <th>Description</th>
	    </tr>
	</thead>
	<tbody>
        <tr id="divicon-html">
            <td><code><b>html</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>Custom HTML code to put inside the div element, empty by default.</td>
        </tr>
        <tr id="divicon-bgpos">
            <td><code><b>bgPos</b></code></td>
            <td><code>Point </code></td>
            <td><code>[0, 0]</code></td>
            <td>Optional relative position of the background, in pixels</td>
        </tr>
	</tbody>
</table>


Options inherited from <a href="#dgicon-options">Icon</a> <!-- TODO: include options -->

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Methods

Methods inherited from <a href="#dgicon-methods">Icon</a> <!-- TODO: include methods -->

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/en/manual/other-layers.md
================================================
## Other Layers

{toc}

### DG.LayerGroup

Used to group several layers and handle them as one. If you add it to the map,
any layers added or removed from the group will be added/removed on the map as
well. Extends <a href="/doc/maps/en/manual/base-classes#dglayer"><code>DG.Layer</code></a>.

    DG.layerGroup([marker1, marker2])
        .addLayer(polyline)
        .addTo(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="layergroup-l-layergroup">
            <td><code><b>DG.layerGroup</b>(
                <nobr>&lt;Layer[]&gt; <i>layers</i> )</nobr>
            </code></td>
            <td>Create a layer group, optionally given an initial set of layers.</td>
        </tr>
    </tbody>
</table>

#### Options

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a> <!-- TODO: include events -->

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layergroup-togeojson">
            <td><code><b>toGeoJSON</b>()</code></td>

            <td><code>Object</code></td>
            <td>Returns a <a href="http://en.wikipedia.org/wiki/GeoJSON">
                <code>GeoJSON</code></a> representation of the layer group (as a GeoJSON <code>GeometryCollection</code>).</td>
        </tr>
        <tr id="layergroup-addlayer">
            <td><code><b>addLayer</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Adds the given layer to the group.</td>
        </tr>
        <tr id="layergroup-removelayer">
            <td><code><b>removeLayer</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Removes the given layer from the group.</td>
        </tr>
        <tr>
            <td><code><b>removeLayer</b>(
                <nobr>&lt;Number&gt; <i>id</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Removes the layer with the given internal ID from the group.</td>
        </tr>
        <tr id="layergroup-haslayer">
            <td><code><b>hasLayer</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the given layer is currently added to the group.</td>
        </tr>
        <tr id="layergroup-clearlayers">
            <td><code><b>clearLayers</b>()</code></td>

            <td><code>this</code></td>
            <td>Removes all the layers from the group.</td>
        </tr>
        <tr id="layergroup-invoke">
            <td><code><b>invoke</b>(
                <nobr>&lt;string&gt; <i>methodName</i>, <i>…</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Calls <code>methodName</code> on every layer contained in this group, passing any
                additional parameters. Has no effect if the layers contained do not
                implement <code>methodName</code>.</td>
        </tr>
        <tr id="layergroup-eachlayer">
            <td><code><b>eachLayer</b>(
                <nobr>&lt;Function&gt; <i>fn</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Iterates over the layers of the group, optionally specifying context of the iterator function.
                <code class="lang-js">group.eachLayer(function (layer) {
                    layer.bindPopup(&#39;Hello&#39;);
                });</code></td>
        </tr>
        <tr id="layergroup-getlayer">
            <td><code><b>getLayer</b>(
                <nobr>&lt;Number&gt; <i>id</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a></code></td>
            <td>Returns the layer with the given internal ID.</td>
        </tr>
        <tr id="layergroup-getlayers">
            <td><code><b>getLayers</b>()</code></td>

            <td><code>Layer[]</code></td>
            <td>Returns an array of all the layers added to the group.</td>
        </tr>
        <tr id="layergroup-setzindex">
            <td><code><b>setZIndex</b>(
                <nobr>&lt;Number&gt; <i>zIndex</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Calls <code>setZIndex</code> on every layer contained in this group, passing the z-index.</td>
        </tr>
        <tr id="layergroup-getlayerid">
            <td><code><b>getLayerId</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Returns the internal ID for a layer</td>
        </tr>
    </tbody>
</table>

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->

### DG.FeatureGroup

Extended <a href="#dglayergroup"><code>DG.LayerGroup</code></a> that also has mouse events
(propagated from members of the group) and a shared bindPopup method.

    DG.featureGroup([marker1, marker2, polyline])
        .bindPopup('Hello world!')
        .on('click', function() { alert('Clicked on a group!'); })
        .addTo(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
	<tbody>
        <tr id="featuregroup-l-featuregroup">
            <td><code><b>DG.featureGroup</b>(
                <nobr>&lt;Layer[]&gt; <i>layers</i> )</nobr>
            </code></td>
            <td>Create a feature group, optionally given an initial set of layers.</td>
        </tr>
    </tbody>
</table>

#### Options

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a> <!-- TODO: include events -->

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="featuregroup-setstyle">
            <td><code><b>setStyle</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/vector-layers#dgpath-options">Path options</a>&gt; <i>style</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Sets the given path options to each layer of the group that has a <code>setStyle</code> method.</td>
        </tr>
        <tr id="featuregroup-bringtofront">
            <td><code><b>bringToFront</b>()</code></td>

            <td><code>this</code></td>
            <td>Brings the layer group to the top of all other layers</td>
        </tr>
        <tr id="featuregroup-bringtoback">
            <td><code><b>bringToBack</b>()</code></td>

            <td><code>this</code></td>
            <td>Brings the layer group to the top of all other layers</td>
        </tr>
        <tr id="featuregroup-getbounds">
            <td><code><b>getBounds</b>()</code></td>

            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlngbounds">LatLngBounds</a></code></td>
            <td>Returns the LatLngBounds of the Feature Group (created from bounds and coordinates of its children).</td>
        </tr>
    </tbody>
</table>

Methods inherited from <a href="#dglayergroup">LayerGroup</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->

### DG.GeoJSON

Represents a GeoJSON object or an array of GeoJSON objects. Allows you to parse
GeoJSON data and display it on the map. Extends <a href="#dgfeaturegroup"><code>DG.FeatureGroup</code></a>.

    DG.geoJson(data, {
        style: function (feature) {
            return {color: feature.properties.color};
        }
    }).bindPopup(function (layer) {
        return layer.feature.properties.description;
    }).addTo(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
	<tbody>
        <tr id="geojson-l-geojson">
            <td><code><b>DG.geoJSON</b>(
                <nobr>&lt;Object&gt; <i>geojson?</i>,</nobr>
                <nobr>&lt;<a href="#geojson-option">GeoJSON options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Creates a GeoJSON layer. Optionally accepts an object in
                <a href="http://geojson.org/geojson-spec.html">GeoJSON format</a> to display on the map
                (you can alternatively add it later with <code>addData</code> method) and an <code>options</code> object.</td>
        </tr>
    </tbody>
</table>

#### Options

<table id="geojson-option">
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
	<tbody>
        <tr id="geojson-pointtolayer">
            <td><code><b>pointToLayer</b></code></td>
            <td><code>Function </code></td>
            <td><code>*</code></td>
            <td>A <code>Function</code> defining how GeoJSON points spawn maps API layers. It is internally
                called when data is added, passing the GeoJSON point feature and its
                <a href="/doc/maps/en/manual/basic-types#dglatlng"><code>LatLng</code></a>.
                The default is to spawn a default <a href="/doc/maps/en/manual/markers#dgmarker"><code>Marker</code></a>:
                <code class="lang-js">function(geoJsonPoint, latlng) {
                    return DG.marker(latlng);
                }
                </code></td>
        </tr>
        <tr id="geojson-style">
            <td><code><b>style</b></code></td>
            <td><code>Function </code></td>
            <td><code>*</code></td>
            <td>A <code>Function</code> defining the
                <a href="/doc/maps/en/manual/vector-layers#dgpath-options"><code>Path options</code></a>
                for styling GeoJSON lines and polygons, called internally when data is added.
                The default value is to not override any defaults:
                <code class="lang-js">function (geoJsonFeature) {
                    return {}
                }
                </code></td>
        </tr>
        <tr id="geojson-oneachfeature">
            <td><code><b>onEachFeature</b></code></td>
            <td><code>Function </code></td>
            <td><code>*</code></td>
            <td>A <code>Function</code> that will be called once for each created
                <a href="/doc/maps/en/manual/base-classes#dglayer"><code>Layer</code></a>,
                after it has been created and styled. Useful for attaching events and popups to features.
                The default is to do nothing with the newly created layers:
                <code class="lang-js">function (layer) {}
                </code></td>
        </tr>
        <tr id="geojson-filter">
            <td><code><b>filter</b></code></td>
            <td><code>Function </code></td>
            <td><code>*</code></td>
            <td>A <code>Function</code> that will be used to decide whether to show a feature or not.
                The default is to show all features:
                <code class="lang-js">function (geoJsonFeature) {
                    return true;
                }
                </code></td>
        </tr>
        <tr id="geojson-coordstolatlng">
            <td><code><b>coordsToLatLng</b></code></td>
            <td><code>Function </code></td>
            <td><code>*</code></td>
            <td>A <code>Function</code> that will be used for converting GeoJSON coordinates to
                <a href="/doc/maps/en/manual/basic-types#dglatlng"><code>LatLng</code></a>s.
                The default is the <code>coordsToLatLng</code> static method.</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a> <!-- TODO: include events -->

#### Methods

Methods inherited from <a href="#dgfeaturegroup">FeatureGroup</a> <!-- TODO: include methods -->

Methods inherited from <a href="#dglayergroup">LayerGroup</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->

#### Functions

There are several static functions which can be called without instantiating DG.GeoJSON:

<table>
    <thead>
        <tr>
            <th>Function</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
	<tbody>
        <tr id="geojson-geometrytolayer">
            <td><code><b>geometryToLayer</b>(
                <nobr>&lt;Object&gt; <i>featureData</i>,</nobr>
                <nobr>&lt;<a href="#geojson-option">GeoJSON options</a>&gt; <i>options?</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a></code></td>
            <td>Creates a <a href="/doc/maps/en/manual/base-classes#dglayer"><code>Layer</code></a> from a given
                GeoJSON feature. Can use a custom <a href="#geojson-pointtolayer"><code>pointToLayer</code></a> and/or
                <a href="#geojson-coordstolatlng"><code>coordsToLatLng</code></a> functions if provided as options.</td>
        </tr>
        <tr id="geojson-coordstolatlng">
            <td><code><b>coordsToLatLng</b>(
                <nobr>&lt;Array&gt; <i>coords</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Creates a <a href="/doc/maps/en/manual/basic-types#dglatlng"><code>LatLng</code></a> object from an array
                of 2 numbers (longitude, latitude) or 3 numbers (longitude, latitude, altitude) used in GeoJSON for points.</td>
        </tr>
        <tr>
            <td><code><b>coordsToLatLngs</b>(
                <nobr>&lt;Array&gt; <i>coords</i>,</nobr>
                <nobr>&lt;Number&gt; <i>levelsDeep?</i>,</nobr>
                <nobr>&lt;Function&gt; <i>coordsToLatLng?</i> )</nobr>
            </code></td>

            <td><code>Array</code></td>
            <td>Creates a multidimensional array of <a href="/doc/maps/en/manual/basic-types#dglatlng"><code>LatLng</code></a>s
                from a GeoJSON coordinates array. <code>levelsDeep</code> specifies the nesting level (0 is for an array
                of points, 1 for an array of arrays of points, etc., 0 by default). Can use a custom
                <a href="#geojson-coordstolatlng"><code>coordsToLatLng</code></a> function.</td>
        </tr>
        <tr id="geojson-latlngtocoords">
            <td><code><b>latLngToCoords</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
            </code></td>

            <td><code>Array</code></td>
            <td>Reverse of <a href="#geojson-coordstolatlng"><code>coordsToLatLng</code></a></td>
        </tr>
        <tr id="geojson-latlngstocoords">
            <td><code><b>latLngsToCoords</b>(
                <nobr>&lt;Array&gt; <i>latlngs</i>,</nobr>
                <nobr>&lt;Number&gt; <i>levelsDeep?</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>closed?</i> )</nobr>
            </code></td>

            <td><code>Array</code></td>
            <td>Reverse of <a href="#geojson-coordstolatlngs"><code>coordsToLatLngs</code></a>
                <code>closed</code> determines whether the first point should be appended to the end of
                the array to close the feature, only used when <code>levelsDeep</code> is 0. False by default.</td>
        </tr>
        <tr id="geojson-asfeature">
            <td><code><b>asFeature</b>(
                <nobr>&lt;Object&gt; <i>geojson</i> )</nobr>
            </code></td>

            <td><code>Object</code></td>
            <td>Normalize GeoJSON geometries/features into GeoJSON features.</td>
        </tr>
    </tbody>
</table>

### DG.GridLayer

Generic class for handling a tiled grid of HTML elements. This is the base class for all tile layers and
replaces <code>TileLayer.Canvas</code>. GridLayer can be extended to create a tiled grid of HTML Elements
like <code>&lt;canvas&gt;</code>, <code>&lt;img&gt;</code> or <code>&lt;div&gt;</code>. GridLayer will
handle creating and animating these DOM elements for you.

#### Synchronous usage

To create a custom layer, extend GridLayer and impliment the <code>createTile()</code> method,
which will be passed a <a href="/doc/maps/en/manual/basic-types#dgpoint"><code>Point</code></a> object with the <code>x</code>,
<code>y</code>, and <code>z</code> (zoom level) coordinates to draw your tile.

    var CanvasLayer = DG.GridLayer.extend({
        createTile: function(coords){
            // create a <canvas> element for drawing
            var tile = DG.DomUtil.create('canvas', 'leaflet-tile');
            // setup tile width and height according to the options
            var size = this.getTileSize();
            tile.width = size.x;
            tile.height = size.y;
            // get a canvas context and draw something on it using coords.x, coords.y and coords.z
            var ctx = canvas.getContext('2d');
            // return the tile so it can be rendered on screen
            return tile;
        }
    });

#### Asynchrohous usage

Tile creation can also be asyncronous, this is useful when using a third-party drawing library.
Once the tile is finsihed drawing it can be passed to the done() callback.

    var CanvasLayer = DG.GridLayer.extend({
        createTile: function(coords, done){
            var error;
            // create a <canvas> element for drawing
            var tile = DG.DomUtil.create('canvas', 'leaflet-tile');
            // setup tile width and height according to the options
            var size = this.getTileSize();
            tile.width = size.x;
            tile.height = size.y;
            // draw something and pass the tile to the done() callback
            done(error, tile);
        }
    });

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
	<tbody>
        <tr id="gridlayer-l-gridlayer">
            <td><code><b>DG.gridLayer</b>(
                <nobr>&lt;GridLayer options&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Creates a new instance of GridLayer with the supplied options.</td>
        </tr>
    </tbody>
</table>

#### Options

<table id='gridlayer-options'>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="gridlayer-tilesize">
            <td><code><b>tileSize</b></code></td>
            <td><code>Number|Point </code></td>
            <td><code>256</code></td>
            <td>Width and height of tiles in the grid. Use a number if width and height are equal,
                or <code>DG.point(width, height)</code> otherwise.</td>
        </tr>
        <tr id="gridlayer-opacity">
            <td><code><b>opacity</b></code></td>
            <td><code>Number </code></td>
            <td><code>1.0</code></td>
            <td>Opacity of the tiles. Can be used in the <code>createTile()</code> function.</td>
        </tr>
        <tr id="gridlayer-updatewhenidle">
            <td><code><b>updateWhenIdle</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>depends</code></td>
            <td>If <code>false</code>, new tiles are loaded during panning, otherwise only after it (for better
                performance). <code>true</code> by default on mobile browsers, otherwise <code>false</code>.</td>
        </tr>
        <tr id="gridlayer-updateinterval">
            <td><code><b>updateInterval</b></code></td>
            <td><code>Number </code></td>
            <td><code>200</code></td>
            <td>Tiles will not update more than once every <code>updateInterval</code> milliseconds.</td>
        </tr>
        <tr id="gridlayer-attribution">
            <td><code><b>attribution</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
            <td>String to be shown in the attribution control, describes the layer data, e.g. &quot;© 2GIS&quot;.</td>
        </tr>
        <tr id="gridlayer-zindex">
            <td><code><b>zIndex</b></code></td>
            <td><code>Number </code></td>
            <td><code>1</code></td>
            <td>The explicit zIndex of the tile layer.</td>
        </tr>
        <tr id="gridlayer-bounds">
            <td><code><b>bounds</b></code></td>
            <td><code>LatLngBounds </code></td>
            <td><code>undefined</code></td>
            <td>If set, tiles will only be loaded inside inside the set
                <a href="/doc/maps/en/manual/basic-types#dglatlngbounds"><code>LatLngBounds</code></a>.</td>
        </tr>
        <tr id="gridlayer-minzoom">
            <td><code><b>minZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>0</code></td>
            <td>The minimum zoom level that tiles will be loaded at. By default the entire map.</td>
        </tr>
        <tr id="gridlayer-maxzoom">
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>undefined</code></td>
            <td>The maximum zoom level that tiles will be loaded at.</td>
        </tr>
        <tr id="gridlayer-nowrap">
            <td><code><b>noWrap</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Whether the layer is wrapped around the antimeridian. If <code>true</code>, the
                GridLayer will only be displayed once at low zoom levels.</td>
        </tr>
        <tr id="gridlayer-pane">
            <td><code><b>pane</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;tilePane&#x27;</code></td>
            <td><code>Map pane</code> where the grid layer will be added.</td>
        </tr>
    </tbody>
</table>

#### Events

<table id='gridlayer-events'>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="gridlayer-loading">
            <td><code><b>loading</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired when the grid layer starts loading tiles</td>
        </tr>
        <tr id="gridlayer-tileunload">
            <td><code><b>tileunload</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#tileevent">TileEvent</a></code></td>
            <td>Fired when a tile is removed (e.g. when a tile goes off the screen).</td>
        </tr>
        <tr id="gridlayer-tileloadstart">
            <td><code><b>tileloadstart</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#tileevent">TileEvent</a></code></td>
            <td>Fired when a tile is requested and starts loading.</td>
        </tr>
        <tr id="gridlayer-tileerror">
            <td><code><b>tileerror</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#tileevent">TileEvent</a></code></td>
            <td>Fired when there is an error loading a tile.</td>
        </tr>
        <tr id="gridlayer-tileload">
            <td><code><b>tileload</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#tileevent">TileEvent</a></code></td>
            <td>Fired when a tile loads.</td>
        </tr>
        <tr id="gridlayer-load">
            <td><code><b>load</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#tileevent">TileEvent</a></code></td>
            <td>Fired when the grid layer loaded all visible tiles.</td>
        </tr>
    </tbody>
</table>

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a> <!-- TODO: include events -->

#### Methods

<table id='gridlayer-methods'>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="gridlayer-bringtofront">
            <td><code><b>bringToFront</b>()</code></td>

            <td><code>this</code></td>
            <td>Brings the tile layer to the top of all tile layers.</td>
        </tr>
        <tr id="gridlayer-bringtoback">
            <td><code><b>bringToBack</b>()</code></td>

            <td><code>this</code></td>
            <td>Brings the tile layer to the bottom of all tile layers.</td>
        </tr>
        <tr id="gridlayer-getattribution">
            <td><code><b>getAttribution</b>()</code></td>

            <td><code>String</code></td>
            <td>Used by the <code>attribution control</code>, returns the
                <a href="#gridlayer-attribution">attribution option</a>.</td>
        </tr>
        <tr id="gridlayer-getcontainer">
            <td><code><b>getContainer</b>()</code></td>

            <td><code>String</code></td>
            <td>Returns the HTML element that contains the tiles for this layer.</td>
        </tr>
        <tr id="gridlayer-setopacity">
            <td><code><b>setOpacity</b>(
                <nobr>&lt;Number&gt; <i>opacity</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Changes the <a href="#gridlayer-opacity">opacity</a> of the grid layer.</td>
        </tr>
        <tr id="gridlayer-setzindex">
            <td><code><b>setZIndex</b>(
                <nobr>&lt;Number&gt; <i>zIndex</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Changes the <a href="#gridlayer-zindex">zIndex</a> of the grid layer.</td>
        </tr>
        <tr id="gridlayer-isloading">
            <td><code><b>isLoading</b>()</code></td>

            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if any tile in the grid layer has not finished loading.</td>
        </tr>
        <tr id="gridlayer-redraw">
            <td><code><b>redraw</b>()</code></td>

            <td><code>this</code></td>
            <td>Causes the layer to clear all the tiles and request them again.</td>
        </tr>
        <tr id="gridlayer-gettilesize">
            <td><code><b>getTileSize</b>()</code></td>

            <td><code><a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Normalizes the <a href="#gridlayer-tilesize">tileSize option</a> into a point.
                Used by the <code>createTile()</code> method.</td>
        </tr>
    </tbody>
</table>

#### Extension methods

Layers extending <a href="#dggridlayer"><code>DG.GridLayer</code></a> shall reimplement the following method.

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
	<tbody>
        <tr id="gridlayer-createtile">
            <td><code><b>createTile</b>(
                <nobr>&lt;Object&gt; <i>coords</i>,</nobr>
                <nobr>&lt;Function&gt; <i>done?</i> )</nobr>
            </code></td>

            <td><code>HTMLElement</code></td>
            <td>Called only internally, must be overriden by classes extending
                <a href="#dggridlayer"><code>GridLayer</code></a>. Returns the <code>HTMLElement</code>
                corresponding to the given <code>coords</code>. If the <code>done</code> callback
                is specified, it must be called when the tile has finished loading and drawing.
            </td>
        </tr>
    </tbody>
</table>

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/en/manual/popup.md
================================================
## Popups

Popup is a window in which you can display arbitrary HTML-code.
Popup associated with a particular location on the map.

{toc}

### DG.Popup

Used to open popups in certain places of the map. Use
<a href="/doc/maps/en/manual/map#map-openpopup">Map.openPopup</a> to
open popups while making sure that only one popup is open at one time
(recommended for usability), or use <a href="/doc/maps/en/manual/map#map-addlayer">Map.addLayer</a>
to open as many as you want.

#### Usage example

If you want to just bind a popup to marker click and then open it, it&#39;s really easy:

	marker.bindPopup(popupContent).openPopup();

Path overlays like polylines also have a <code>bindPopup</code> method.
Here&#39;s a more complicated way to open a popup on a map:

	var popup = DG.popup()
		.setLatLng(latlng)
		.setContent(&#39;&lt;p&gt;Hello world!&lt;br /&gt;This is a nice popup.&lt;/p&gt;&#39;)
		.openOn(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="popup-dg-popup">
            <td><code><b>DG.popup</b>(
                    <nobr>&lt;<a href="#options">Popup options</a>&gt; <i>options?</i></nobr>,
                    <nobr>&lt;<a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a>&gt; <i>source?</i>)</nobr>
                </code></td>
            <td>Instantiates a Popup object given an optional <code>options</code> object that describes
                its appearance and location and an optional <code>source</code> object that is used to tag
                the popup with a reference to the Layer to which it refers.</td>
        </tr>
    </tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="popup-maxwidth">
            <td><code><b>maxWidth</b></code></td>
            <td><code>Number </code></td>
            <td><code>300</code></td>
            <td>Max width of the popup, in pixels.</td>
        </tr>
        <tr id="popup-minwidth">
            <td><code><b>minWidth</b></code></td>
            <td><code>Number </code></td>
            <td><code>50</code></td>
            <td>Min width of the popup, in pixels.</td>
        </tr>
        <tr id="popup-maxheight">
            <td><code><b>maxHeight</b></code></td>
            <td><code>Number </code></td>
            <td><code>null</code></td>
            <td>If set, creates a scrollable container of the given height
                inside a popup if its content exceeds it.</td>
        </tr>
        <tr id="popup-autopan">
            <td><code><b>autoPan</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Set it to <code>false</code> if you don&#39;t want the map to do panning animation
                to fit the opened popup.</td>
        </tr>
        <tr id="popup-autopanpaddingtopleft">
            <td><code><b>autoPanPaddingTopLeft</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
            <td>The margin between the popup and the top left corner of the map
                view after autopanning was performed.</td>
        </tr>
        <tr id="popup-autopanpaddingbottomright">
            <td><code><b>autoPanPaddingBottomRight</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
            <td>The margin between the popup and the bottom right corner of the map
                view after autopanning was performed.</td>
        </tr>
        <tr id="popup-autopanpadding">
            <td><code><b>autoPanPadding</b></code></td>
            <td><code>Point </code></td>
            <td><code>Point(5, 5)</code></td>
            <td>Equivalent of setting both top left and bottom right autopan padding to the same value.</td>
        </tr>
        <tr id="popup-keepinview">
            <td><code><b>keepInView</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Set it to <code>true</code> if you want to prevent users from panning the popup
                off of the screen while it is open.</td>
        </tr>
        <tr id="popup-closebutton">
            <td><code><b>closeButton</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Controls the presence of a close button in the popup.</td>
        </tr>
        <tr id="popup-offset">
            <td><code><b>offset</b></code></td>
            <td><code>Point </code></td>
            <td><code>Point(0, 7)</code></td>
            <td>The offset of the popup position. Useful to control the anchor
                of the popup when opening it on some overlays.</td>
        </tr>
        <tr id="popup-autoclose">
            <td><code><b>autoClose</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Set it to <code>false</code> if you want to override the default behavior of
                the popup closing when user clicks the map (set globally by the Map&#39;s
                <a href="/doc/maps/en/manual/map#map-closepopuponclick">closePopupOnClick</a> option).</td>
        </tr>
        <tr id="popup-zoomanimation">
            <td><code><b>zoomAnimation</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether to animate the popup on zoom. Disable it if you have
                problems with Flash content inside popups.</td>
        </tr>
        <tr id="popup-classname">
            <td><code><b>className</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>A custom CSS class name to assign to the popup.</td>
        </tr>
        <tr id="popup-pane">
            <td><code><b>pane</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;popupPane&#x27;</code></td>
            <td><code>Map pane</code> where the popup will be added.</td>
        </tr>
        <tr id="popup-sprawling">
            <td><code><b>sprawling</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>false</code></td>
            <td><!-- TODO: translation --></td>
        </tr>
        <tr id="popup-textdirection">
            <td><code><b>textDirection</b></code></td>
            <td><code>string</code></td>
            <td><code>'auto'</code></td>
            <td>The direction of the popup content text. The following values are possible: <code>'auto'</code>,
                <code>'rtl'</code>, <code>'ltr'</code>.</td>
        </tr>
    </tbody>
</table>

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="popup-add">
            <td><code><b>add</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired after the layer is added to a map</td>
        </tr>
        <tr id="popup-remove">
            <td><code><b>remove</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#event">Event</a></code></td>
            <td>Fired after the layer is removed from a map</td>
        </tr>
    </tbody>
</table>

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

<table>
    <thead>
        <tr>
            <th>Event</th>
            <th>Data</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="popup-popupopen">
            <td><code><b>popupopen</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Fired when a popup bound to this layer is opened</td>
        </tr>
        <tr id="popup-popupclose">
            <td><code><b>popupclose</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Fired when a popup bound to this layer is closed</td>
        </tr>
    </tbody>
</table>

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="popup-addto">
            <td><code><b>addTo</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/map#dgmap">Map</a>&gt; <i>map</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Adds the popup to the map.</td>
        </tr>
        <tr id="popup-openon">
            <td><code><b>openOn</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/map#dgmap">Map</a>&gt; <i>map</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Adds the popup to the map and closes the previous one. The same as <code>map.openPopup(popup)</code>.</td>
        </tr>
        <tr id="popup-getlatlng">
            <td><code><b>getLatLng</b>()</code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Returns the geographical point of popup.</td>
        </tr>
        <tr id="popup-setlatlng">
            <td><code><b>setLatLng</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Sets the geographical point where the popup will open.</td>
        </tr>
        <tr id="popup-getcontent">
            <td><code><b>getContent</b>()</code></td>
            <td><code>String|HTMLElement</code></td>
            <td>Returns the main content of the popup.</td>
        </tr>
        <tr id="popup-setcontent">
            <td><code><b>setContent</b>(
                <nobr>&lt;String | HTMLElement | Function&gt; <i>htmlContent</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Sets the HTML content of the popup (in main section). If a function is passed the source layer will
                be passed to the function. The function should return a <code>String</code> or
                <code>HTMLElement</code> to be used in the popup.</td>
        </tr>
        <tr id="popup-getheadercontent">
            <td><code><b>getHeaderContent</b>()</code></td>
            <td><code>String | HTMLElement</code></td>
            <td>Returns the content of the header section of the popup.</td>
        </tr>
        <tr id="popup-setheadercontent">
            <td><code><b>setHeaderContent</b>(
                <nobr>&lt;String|HTMLElement&gt; <i>htmlContent</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Sets the content of the header section of the popup.</td>
        </tr>
        <tr id="popup-getfootercontent">
            <td><code><b>getFooterContent</b>()</code></td>
            <td><code>String | HTMLElement</code></td>
            <td>Returns the content of the footer section of the popup.</td>
        </tr>
        <tr id="popup-setfootercontent">
            <td><code><b>setFooterContent</b>(
                <nobr>&lt;String | HTMLElement&gt; <i>htmlContent</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Sets the content of the footer section of the popup.</td>
        </tr>
        <tr id="popup-getelement">
            <td><code><b>getElement</b>()</code></td>
            <td><code>String | HTMLElement</code></td>
            <td>Alias for <a href="#popup-getcontent">getContent()</a></td>
        </tr>
        <tr id="popup-update">
            <td><code><b>update</b>()</code></td>
            <td><code>null</code></td>
            <td>Updates the popup content, layout and position. Useful for updating the popup after
                something inside changed, e.g. image loaded.</td>
        </tr>
        <tr id="popup-isopen">
            <td><code><b>isOpen</b>()</code></td>
            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> when the popup is visible on the map.</td>
        </tr>
        <tr id="popup-bringtofront">
            <td><code><b>bringToFront</b>()</code></td>
            <td><code>this</code></td>
            <td>Brings this popup in front of other popups (in the same map pane).</td>
        </tr>
        <tr id="popup-bringtoback">
            <td><code><b>bringToBack</b>()</code></td>
            <td><code>this</code></td>
            <td>Brings this popup to the back of other popups (in the same map pane).</td>
        </tr>
    </tbody>
</table>

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/en/manual/raster-layers.md
================================================
## Raster Layers

This section describes working with raster layers, such as a tile layer
or an image bound to specific geographic boundaries.

{toc}

### DG.TileLayer

Used to load and display tile layers on the map. Extends <a href="/doc/maps/en/manual/other-layers#dggridlayer">GridLayer</a>.

#### Usage Example

    DG.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png?{foo}', {foo: 'bar'}).addTo(map);

##### URL Template

A string of the following form:

    'http://{s}.somedomain.com/blabla/{z}/{x}/{y}{r}.png'

You can use custom keys in the template, which will be evaluated from TileLayer options, like this:

    DG.tileLayer('http://{s}.somedomain.com/{foo}/{z}/{x}/{y}.png', {foo: 'bar'});

#### Creation

Extension methods

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-dg-tilelayer">
            <td><code>
                    <b>DG.tilelayer</b>(
                    <nobr>&lt;String&gt;</nobr> <i>urlTemplate</i>,
                    <nobr><i>options</i></nobr>)
                </code>
            </td>
            <td>Instantiates a tile layer object given a <code>URL template</code> and optionally an options object.
            </td>
        </tr>
    </tbody>
</table>

#### Options

<table id="tilelayer-options">
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-minzoom">
            <td><code><b>minZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>0</code></td>
            <td>Minimum zoom number.</td>
        </tr>
        <tr id="tilelayer-maxzoom">
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>18</code></td>
            <td>Maximum zoom number.</td>
        </tr>
        <tr id="tilelayer-maxnativezoom">
            <td><code><b>maxNativeZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>null</code></td>
            <td>Maximum zoom number the tile source has available. If it is specified,
                the tiles on all zoom levels higher than <code>maxNativeZoom</code> will be loaded
                from <code>maxNativeZoom</code> level and auto-scaled.
            </td>
        </tr>
        <tr id="tilelayer-subdomains">
            <td><code><b>subdomains</b></code></td>
            <td><code>String|String[] </code></td>
            <td><code>&#x27;abc&#x27;</code></td>
            <td>Subdomains of the tile service. Can be passed in the form of one string (where each letter
                is a subdomain name) or an array of strings.
            </td>
        </tr>
        <tr id="tilelayer-errortileurl">
            <td><code><b>errorTileUrl</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>URL to the tile image to show in place of the tile that failed to load.</td>
        </tr>
        <tr id="tilelayer-zoomoffset">
            <td><code><b>zoomOffset</b></code></td>
            <td><code>Number </code></td>
            <td><code>0</code></td>
            <td>The zoom number used in tile URLs will be offset with this value.</td>
        </tr>
        <tr id="tilelayer-tms">
            <td><code><b>tms</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If <code>true</code>, inverses Y axis numbering for tiles (turn this on for TMS services).</td>
        </tr>
        <tr id="tilelayer-zoomreverse">
            <td><code><b>zoomReverse</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If set to true, the zoom number used in tile URLs will be reversed
                (<code>maxZoom - zoom</code> instead of <code>zoom</code>)
            </td>
        </tr>
        <tr id="tilelayer-detectretina">
            <td><code><b>detectRetina</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If <code>true</code> and user is on a retina display, it will request four tiles of half
                the specified size and a bigger zoom level in place of one to utilize the high resolution.
            </td>
        </tr>
        <tr id="tilelayer-crossorigin">
            <td><code><b>crossOrigin</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If true, all tiles will have their crossOrigin attribute set to &#39;&#39;. This is needed if
                you want to access tile pixel data.
            </td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="/doc/maps/en/manual/other-layers#gridlayer-options">GridLayer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/other-layers#gridlayer-events">GridLayer</a> <!-- TODO: include events -->

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Methods

<table id="tilelayer-methods">
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-seturl">
            <td><code><b>setUrl</b>(
                <nobr>&lt;String&gt; <i>url</i></nobr>
                <nobr>&lt;Boolean&gt; <i>noRedraw?</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Updates the layer&#39;s URL template and redraws it (unless <code>noRedraw</code>
                is set to <code>true</code>).
            </td>
        </tr>
        <tr id="tilelayer-createtile">
            <td><code><b>createTile</b>(
                <nobr>&lt;Object&gt;</nobr> <i>coords</i>,
                <nobr>&lt;Function&gt;</nobr> <i>done?</i>)</nobr>
            </code></td>
            <td><code>HTMLElement</code></td>
            <td>Called only internally, overrides GridLayer&#39;s
                <a href="/doc/maps/en/manual/other-layers#gridlayer-createtile"><code>createTile()</code></a>
                to return an <code>&lt;img&gt;</code> HTML element with the appropiate
                image URL given <code>coords</code>. The <code>done</code>
                callback is called when the tile has been loaded.
            </td>
        </tr>
    </tbody>
</table>

##### Extension methods

Layers extending <a href="#dgtilelayer">TileLayer</a> might reimplement the following method.

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-gettileurl">
            <td><code><b>getTileUrl</b>(<nobr>&lt;Object&gt;</nobr> <i>coords</i>)</nobr></code></td>
            <td><code>String</code></td>
            <td>Called only internally, returns the URL for a tile given its coordinates.
                Classes extending <a href="#dgtilelayer"><code>TileLayer</code></a> can override
                this function to provide custom tile URL naming schemes.</td>
        </tr>
    </tbody>
</table>

Methods inherited from GridLayer <a href="/doc/maps/en/manual/other-layers#gridlayer-methods">GridLayer</a> <!-- TODO: include methods -->

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.TileLayer.wms

Used to display WMS services as tile layers on the map. Extends <a href="#dgtilelayer">TileLayer</a>.

#### Usage Example

    var nexrad = DG.tileLayer.wms("http://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0r.cgi", {
        layers: 'nexrad-n0r-900913',
        format: 'image/png',
        transparent: true,
        attribution: "Weather data © 2012 IEM Nexrad"
    });

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-wms-dg-tilelayer-wms">
            <td><code><b>DG.tileLayer.wms</b>(
                <nobr>&lt;String&gt; <i>baseUrl</i></nobr>,
                <nobr>&lt;<a href="#tilelayer-wms-options">TileLayer.WMS options</a>&gt; <i>options</i>)</nobr>
            </code></td>
            <td>Instantiates a WMS tile layer object given a base URL of the WMS service and a WMS
                parameters/options object.
            </td>
        </tr>
    </tbody>
</table>

#### Options

<table id="tilelayer-wms-options">
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-wms-layers">
            <td><code><b>layers</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td><strong>(required)</strong> Comma-separated list of WMS layers to show.</td>
        </tr>
        <tr id="tilelayer-wms-styles">
            <td><code><b>styles</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>Comma-separated list of WMS styles.</td>
        </tr>
        <tr id="tilelayer-wms-format">
            <td><code><b>format</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;image/jpeg&#x27;</code></td>
            <td>WMS image format (use <code>&#39;image/png&#39;</code> for layers with transparency).</td>
        </tr>
        <tr id="tilelayer-wms-transparent">
            <td><code><b>transparent</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If <code>true</code>, the WMS service will return images with transparency.</td>
        </tr>
        <tr id="tilelayer-wms-version">
            <td><code><b>version</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;1.1.1&#x27;</code></td>
            <td>Version of the WMS service to use</td>
        </tr>
        <tr id="tilelayer-wms-crs">
            <td><code><b>crs</b></code></td>
            <td><code>CRS </code></td>
            <td><code>null</code></td>
            <td>Coordinate Reference System to use for the WMS requests, defaults to
                map CRS. Don&#39;t change this if you&#39;re not sure what it means.
            </td>
        </tr>
        <tr id="tilelayer-wms-uppercase">
            <td><code><b>uppercase</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If <code>true</code>, WMS request parameter keys will be uppercase.</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="#tilelayer-options">TileLayer</a> <!-- TODO: include options -->

Options inherited from <a href="/doc/maps/en/manual/other-layers#gridlayer-options">GridLayer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/other-layers#gridlayer-events">GridLayer</a> <!-- TODO: include events -->

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->


#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-wms-setparams">
            <td><code><b>setParams</b>(
                <nobr>&lt;Object&gt; <i>params</i></nobr>,
                <nobr>&lt;Boolean&gt; <i>noRedraw?</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Merges an object with the new parameters and re-requests tiles on the current screen
                (unless <code>noRedraw</code> was set to true).
            </td>
        </tr>
    </tbody>
</table>

Methods inherited from TileLayer <a href="#tilelayer-methods">TileLayer</a> <!-- TODO: include methods -->

Methods inherited from GridLayer <a href="/doc/maps/en/manual/other-layers#gridlayer-methods">GridLayer</a> <!-- TODO: include methods -->

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.ImageOverlay

Used to load and display a single image over specific bounds of the map. Extends Layer.

#### Usage Example

    var imageUrl = 'http://www.lib.utexas.edu/maps/historical/newark_nj_1922.jpg',
        imageBounds = [[40.712216, -74.22655], [40.773941, -74.12544]];
    DG.imageOverlay(imageUrl, imageBounds).addTo(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="imageoverlay-l-imageoverlay">
            <td><code><b>L.imageOverlay</b>(
                <nobr>&lt;String&gt; <i>imageUrl</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>bounds</i></nobr>,
                <nobr>&lt;ImageOverlay options&gt;</nobr> <i>options?</i></nobr>)
            </code></td>
            <td>Instantiates an image overlay object given the URL of the image and the
                geographical bounds it is tied to.
            </td>
        </tr>
    </tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="imageoverlay-opacity">
            <td><code><b>opacity</b></code></td>
            <td><code>Number </code></td>
            <td><code>1.0</code></td>
            <td>The opacity of the image overlay.</td>
        </tr>
        <tr id="imageoverlay-alt">
            <td><code><b>alt</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>Text for the <code>alt</code> attribute of the image (useful for accessibility).</td>
        </tr>
        <tr id="imageoverlay-interactive">
            <td><code><b>interactive</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If <code>true</code>, the image overlay will emit mouse events when clicked or hovered.</td>
        </tr>
        <tr id="imageoverlay-attribution">
            <td><code><b>attribution</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
            <td>An optional string containing HTML to be shown on the <code>Attribution control</code></td>
        </tr>
        <tr id="imageoverlay-crossorigin">
            <td><code><b>crossOrigin</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>If true, the image will have its crossOrigin attribute set to &#39;&#39;.
                This is needed if you want to access image pixel data.</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Mehtods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="imageoverlay-setopacity">
            <td><code><b>setOpacity</b>()</nobr></code></td>
            <td><code>this</code></td>
            <td>Sets the opacity of the overlay.</td>
        </tr>
        <tr id="imageoverlay-bringtofront">
            <td><code><b>bringToFront</b>()</nobr></code></td>
            <td><code>this</code></td>
            <td>Brings the layer to the top of all overlays.</td>
        </tr>
        <tr id="imageoverlay-bringtoback">
            <td><code><b>bringToBack</b>()</nobr></code></td>
            <td><code>this</code></td>
            <td>Brings the layer to the bottom of all overlays.</td>
        </tr>
        <tr id="imageoverlay-seturl">
            <td><code><b>setUrl</b>(<nobr>&lt;String&gt; <i>url</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Changes the URL of the image.</td>
        </tr>
    </tbody>
</table>

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/en/manual/utils.md
================================================
## Utility

{toc}

### DG.Browser

A namespace with static properties for browser/feature detection.

    if (DG.Browser.ie6) {
        alert('Upgrade your browser, dude!');
    }

#### Properties

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="browser-ie">
            <td><code><b>ie</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for all Internet Explorer versions (not Edge).</td>
        </tr>
        <tr id="browser-ielt9">
            <td><code><b>ielt9</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for Internet Explorer versions less than 9.</td>
        </tr>
        <tr id="browser-edge">
            <td><code><b>edge</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for the Edge web browser.</td>
        </tr>
        <tr id="browser-webkit">
            <td><code><b>webkit</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for webkit-based browsers like Chrome and Safari (including mobile versions).</td>
        </tr>
        <tr id="browser-gecko">
            <td><code><b>gecko</b></code></td>
            <td><code>Boolean</code></td>
		    <td><code>true</code> for gecko-based browsers like Firefox.</td>
        </tr>
        <tr id="browser-android">
            <td><code><b>android</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for any browser running on an Android platform.</td>
        </tr>
        <tr id="browser-android23">
            <td><code><b>android23</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for browsers running on Android 2 or Android 3.</td>
        </tr>
        <tr id="browser-chrome">
            <td><code><b>chrome</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for the Chrome browser.</td>
        </tr>
        <tr id="browser-safari">
            <td><code><b>safari</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for the Safari browser.</td>
        </tr>
        <tr id="browser-ie3d">
            <td><code><b>ie3d</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for all Internet Explorer versions supporting CSS transforms.</td>
        </tr>
        <tr id="browser-webkit3d">
            <td><code><b>webkit3d</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for webkit-based browsers supporting CSS transforms.</td>
        </tr>
        <tr id="browser-gecko3d">
            <td><code><b>gecko3d</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for gecko-based browsers supporting CSS transforms.</td>
        </tr>
        <tr id="browser-opera12">
            <td><code><b>opera12</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for the Opera browser supporting CSS transforms (version 12 or later).</td>
        </tr>
        <tr id="browser-any3d">
            <td><code><b>any3d</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for all browsers supporting CSS transforms.</td>
        </tr>
        <tr id="browser-mobile">
            <td><code><b>mobile</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for all browsers running in a mobile device.</td>
        </tr>
        <tr id="browser-mobilewebkit">
            <td><code><b>mobileWebkit</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for all webkit-based browsers in a mobile device.</td>
        </tr>
        <tr id="browser-mobilewebkit3d">
            <td><code><b>mobileWebkit3d</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for all webkit-based browsers in a mobile device supporting CSS transforms.</td>
        </tr>
        <tr id="browser-mobileopera">
            <td><code><b>mobileOpera</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for the Opera browser in a mobile device.</td>
        </tr>
        <tr id="browser-mobilegecko">
            <td><code><b>mobileGecko</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for gecko-based browsers running in a mobile device.</td>
        </tr>
        <tr id="browser-touch">
            <td><code><b>touch</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for all browsers supporting <a href="https://developer.mozilla.org/docs/Web/API/Touch_events">touch events</a>.</td>
        </tr>
        <tr id="browser-mspointer">
            <td><code><b>msPointer</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for browsers implementing the Microsoft touch events model (notably IE10).</td>
        </tr>
        <tr id="browser-pointer">
            <td><code><b>pointer</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for all browsers supporting <a href="https://msdn.microsoft.com/en-us/library/dn433244%28v=vs.85%29.aspx">pointer events</a>.</td>
        </tr>
        <tr id="browser-retina">
            <td><code><b>retina</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> for browsers on a high-resolution &quot;retina&quot; screen.</td>
        </tr>
        <tr id="browser-canvas">
            <td><code><b>canvas</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> when the browser supports <a href="https://developer.mozilla.org/docs/Web/API/Canvas_API"><code>&lt;canvas&gt;</code></a>.</td>
        </tr>
        <tr id="browser-vml">
            <td><code><b>vml</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> if the browser supports <a href="https://en.wikipedia.org/wiki/Vector_Markup_Language">VML</a>.</td>
        </tr>
        <tr id="browser-svg">
            <td><code><b>svg</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> when the browser supports <a href="https://developer.mozilla.org/docs/Web/SVG">SVG</a>.</td>
        </tr>
    </tbody>
</table>

### DG.Util

Various utility functions.

#### Functions

<table>
    <thead>
        <tr>
            <th>Function</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="util-extend">
            <td><code><b>extend</b>(
                <nobr>&lt;Object&gt; <i>dest</i>,</nobr>
                <nobr>&lt;Object&gt; <i>src?</i> )</nobr>
            </code></td>

            <td><code>Object</code></td>
            <td>Merges the properties of the <code>src</code> object (or multiple objects) into <code>dest</code>
                object and returns the latter. Has an <code>DG.extend</code> shortcut.</td>
        </tr>
        <tr id="util-create">
            <td><code><b>create</b>(
                <nobr>&lt;Object&gt; <i>proto</i>,</nobr>
                <nobr>&lt;Object&gt; <i>properties?</i> )</nobr>
            </code></td>

            <td><code>Object</code></td>
            <td>Compatibility polyfill for
                <a href="https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/create">Object.create</a></td>
        </tr>
        <tr id="util-bind">
            <td><code><b>bind</b>(
                <nobr>&lt;Function&gt; <i>fn</i>, <i>…</i> )</nobr>
            </code></td>

            <td><code>Function</code></td>
            <td>Returns a new function bound to the arguments passed, like
                <a href="https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">Function.prototype.bind</a>.
                Has a <code>DG.bind()</code> shortcut.</td>
        </tr>
        <tr id="util-stamp">
            <td><code><b>stamp</b>(
                <nobr>&lt;Object&gt; <i>obj</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Returns the unique ID of an object, assiging it one if it doesn&#39;t have it.</td>
        </tr>
        <tr id="util-throttle">
            <td><code><b>throttle</b>(
                <nobr>&lt;Function&gt; <i>fn</i>,</nobr>
                <nobr>&lt;Number&gt; <i>time</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context</i> )</nobr>
            </code></td>

            <td><code>Function</code></td>
            <td>Returns a function which executes function <code>fn</code> with the given scope <code>context</code>
                (so that the <code>this</code> keyword refers to <code>context</code> inside <code>fn</code>&#39;s code).
                The arguments received by the bound function will be any arguments passed when binding the function,
                followed by any arguments passed when invoking the bound function. Has an <code>DG.bind</code> shortcut.</td>
        </tr>
        <tr id="util-wrapnum">
            <td><code><b>wrapNum</b>(
                <nobr>&lt;Number&gt; <i>num</i>,</nobr>
                <nobr>&lt;Number[]&gt; <i>range</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>includeMax?</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Returns the number <code>num</code> modulo <code>range</code> in such a way so it lies within
                <code>range[0]</code> and <code>range[1]</code>. The returned value will be always smaller than
                <code>range[1]</code> unless <code>includeMax</code> is set to <code>true</code>.</td>
        </tr>
        <tr id="util-falsefn">
            <td><code><b>falseFn</b>()</code></td>

            <td><code>Function</code></td>
            <td>Returns a function which always returns <code>false</code>.</td>
        </tr>
        <tr id="util-formatnum">
            <td><code><b>formatNum</b>(
                <nobr>&lt;Number&gt; <i>num</i>,</nobr>
                <nobr>&lt;Number&gt; <i>digits?</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Returns the number <code>num</code> rounded to <code>digits</code> decimals, or to 5 decimals by default.</td>
        </tr>
        <tr id="util-trim">
            <td><code><b>trim</b>(
                <nobr>&lt;String&gt; <i>str</i> )</nobr>
            </code></td>

            <td><code>String</code></td>
            <td>Compatibility polyfill for
                <a href="https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim">String.prototype.trim</a></td>
        </tr>
        <tr id="util-splitwords">
            <td><code><b>splitWords</b>(
                <nobr>&lt;String&gt; <i>str</i> )</nobr>
            </code></td>

            <td><code>String[]</code></td>
            <td>Trims and splits the string on whitespace and returns the array of parts.</td>
        </tr>
        <tr id="util-setoptions">
            <td><code><b>setOptions</b>(
                <nobr>&lt;Object: options: Object&gt; <i>obj</i> )</nobr>
            </code></td>

            <td><code>Object</code></td>
            <td>Merges the given properties to the <code>options</code> of the <code>obj</code> object, returning
                the resulting options. See <code>Class options</code>. Has an <code>DG.setOptions</code> shortcut.</td>
        </tr>
        <tr id="util-getparamstring">
            <td><code><b>getParamString</b>(
                <nobr>&lt;Object&gt; <i>obj</i>,</nobr>
                <nobr>&lt;String&gt; <i>existingUrl?</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>uppercase?</i> )</nobr>
            </code></td>

            <td><code>String</code></td>
            <td>Converts an object into a parameter URL string, e.g. <code>{a: &quot;foo&quot;, b: &quot;bar&quot;}</code>
                translates to <code>&#39;?a=foo&amp;b=bar&#39;</code>. If <code>existingUrl</code> is set, the parameters will
                be appended at the end. If <code>uppercase</code> is <code>true</code>, the parameter names will
                be uppercased (e.g. <code>&#39;?A=foo&amp;B=bar&#39;</code>)
                Simple templating facility, accepts a template string of the form <code>&#39;Hello {a}, {b}&#39;</code>
                and a data object like <code>{a: &#39;foo&#39;, b: &#39;bar&#39;}</code>, returns evaluated string
                <code>(&#39;Hello foo, bar&#39;)</code>. You can also specify functions instead of strings for
                data values — they will be evaluated passing <code>data</code> as an argument.</td>
        </tr>
        <tr id="util-isarray">
            <td><code><b>isArray</b>(<i>obj</i>)</code></td>

            <td><code>Boolean</code></td>
            <td>Compatibility polyfill for
                <a href="https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray">Array.isArray</a></td>
        </tr>
        <tr id="util-indexof">
            <td><code><b>indexOf</b>()</code></td>

            <td><code>Number</code></td>
            <td>Compatibility polyfill for
                <a href="https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf">Array.prototype.indexOf</a></td>
        </tr>
        <tr id="util-requestanimframe">
            <td><code><b>requestAnimFrame</b>(
                <nobr>&lt;Function&gt; <i>fn</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>immediate?</i> )</nobr>
            </code></td>

            <td><code>requestId: Number</code></td>
            <td>Schedules <code>fn</code> to be executed when the browser repaints. <code>fn</code> is bound to
                <code>context</code> if given. When <code>immediate</code> is set, <code>fn</code> is called immediately if
                the browser doesn&#39;t have native support for
                <a href="https://developer.mozilla.org/docs/Web/API/window/requestAnimationFrame"><code>window.requestAnimationFrame</code></a>,
                otherwise it&#39;s delayed. Returns an id that can be used to cancel the request.</td>
        </tr>
        <tr id="util-cancelanimframe">
            <td><code><b>cancelAnimFrame</b>(
                <nobr>&lt;Number&gt; <i>id</i> )</nobr>
            </code></td>
            <td><code></code></td>
            <td>Cancels a previous <code>requestAnimFrame</code>. See also
                <a href="https://developer.mozilla.org/docs/Web/API/window/cancelAnimationFrame">window.cancelAnimationFrame</a>.</td>
        </tr>
    </tbody>
</table>

#### Properties

<table>
    <thead>
        <tr>
            <th>Property</th>
            <th>Type</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="util-lastid">
            <td><code><b>lastId</b></code></td>
            <td><code>Number</code></td>
            <td>Last unique ID used by <a href="#util-stamp"><code>stamp()</code></a></td>
        </tr>
        <tr id="util-emptyimageurl">
            <td><code><b>emptyImageUrl</b></code></td>
            <td><code>String</code></td>
            <td>Data URI string containing a base64-encoded empty GIF image.
                Used as a hack to free memory from unused images on WebKit-powered
                mobile devices (by setting image <code>src</code> to this string).</td>
        </tr>
    </tbody>
</table>

### DG.LineUtil

Various utility functions for polyine points processing, used by Leaflet internally to make polylines lightning-fast.

#### Functions

<table>
    <thead>
        <tr>
            <th>Function</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="lineutil-simplify">
            <td><code><b>simplify</b>(
                <nobr>&lt;Point[]&gt; <i>points</i>,</nobr>
                <nobr>&lt;Number&gt; <i>tolerance</i> )</nobr>
            </code></td>

            <td><code>Point[]</code></td>
            <td>Dramatically reduces the number of points in a polyline while retaining
                its shape and returns a new array of simplified points, using the
                <a href="http://en.wikipedia.org/wiki/Douglas-Peucker_algorithm">Douglas-Peucker algorithm</a>.
                Used for a huge performance boost when processing/displaying Leaflet polylines for
                each zoom level and also reducing visual noise. tolerance affects the amount of
                simplification (lesser value means higher quality but slower and with more points).
                Also released as a separated micro-library <a href="http://mourner.github.com/simplify-js/">Simplify.js</a>.</td>
        </tr>
        <tr id="lineutil-pointtosegmentdistance">
            <td><code><b>pointToSegmentDistance</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>p</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>p1</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>p2</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Returns the distance between point <code>p</code> and segment <code>p1</code> to <code>p2</code>.</td>
        </tr>
        <tr id="lineutil-closestpointonsegment">
            <td><code><b>closestPointOnSegment</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>p</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>p1</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgpoint">Point</a>&gt; <i>p2</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Returns the closest point from a point <code>p</code> on a segment <code>p1</code> to <code>p2</code>.</td>
        </tr>
    </tbody>
</table>

### DG.PolyUtil

Various utility functions for polygon geometries.

#### Functions

<table>
    <thead>
        <tr>
            <th>Function</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr id="polyutil-clippolygon">
		    <td><code><b>clipPolygon</b>(
		        <nobr>&lt;Point[]&gt; <i>points</i>,</nobr>
		        <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dgbounds">Bounds</a>&gt; <i>bounds</i>,</nobr>
		        <nobr>&lt;Boolean&gt; <i>round?</i> )</nobr>
		    </code></td>

    		<td><code>Point[]</code></td>
    		<td>Clips the polygon geometry defined by the given <code>points</code> by the given bounds
    		    (using the <a href="https://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman_algorithm">Sutherland-Hodgeman algorithm</a>).
                Used by Leaflet to only show polygon points that are on the screen or near, increasing
                performance. Note that polygon points needs different algorithm for clipping
                than polyline, so there&#39;s a seperate method for it.</td>
    	</tr>
    </tbody>
</table>


================================================
FILE: src/doc/en/manual/vector-layers.md
================================================
## Vector Layers

This section describes classes for working with vector layers - a geometrical
objects like circles, polylines and polygons.

{toc}

### DG.Path

An abstract class that contains options and constants shared between vector overlays 
(Polygon, Polyline, Circle). Do not use it directly. Extends <a href="/doc/maps/en/manual/base-classes#dglayer">Layer</a>.

#### Options

<table id="dgpath-options">
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="path-stroke">
            <td><code><b>stroke</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Whether to draw stroke along the path. Set it to <code>false</code>
                to disable borders on polygons or circles.</td>
        </tr>
        <tr id="path-color">
            <td><code><b>color</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;#3388ff&#x27;</code></td>
            <td>Stroke color</td>
        </tr>
        <tr id="path-weight">
            <td><code><b>weight</b></code></td>
            <td><code>Number </code></td>
            <td><code>3</code></td>
            <td>Stroke width in pixels</td>
        </tr>
        <tr id="path-opacity">
            <td><code><b>opacity</b></code></td>
            <td><code>Number </code></td>
            <td><code>1.0</code></td>
            <td>Stroke opacity</td>
        </tr>
        <tr id="path-linecap">
            <td><code><b>lineCap</b></code></td>
            <td><code>String</code></td>
            <td><code>&#x27;round&#x27;</code></td>
            <td>A string that defines
                <a href="https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-linecap">shape to be
                used at the end</a> of the stroke.</td>
        </tr>
        <tr id="path-linejoin">
            <td><code><b>lineJoin</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;round&#x27;</code></td>
            <td>A string that defines
                <a href="https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-linejoin">shape to
                be used at the corners</a> of the stroke.</td>
        </tr>
        <tr id="path-dasharray">
            <td><code><b>dashArray</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
            <td>A string that defines the stroke
                <a href="https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-dasharray">dash pattern</a>.
                Doesn&#39;t work on canvas-powered layers (e.g. Android 2).</td>
        </tr>
        <tr id="path-dashoffset">
            <td><code><b>dashOffset</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
            <td>A string that defines the
                <a href="https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-dashoffset">distance
                into the dash pattern to start the dash</a>. Doesn&#39;t work on canvas-powered layers</td>
        </tr>
        <tr id="path-fill">
            <td><code><b>fill</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>depends</code></td>
            <td>Whether to fill the path with color. Set it to <code>false</code> to disable
                filling on polygons or circles.</td>
        </tr>
        <tr id="path-fillcolor">
            <td><code><b>fillColor</b></code></td>
            <td><code>String </code></td>
            <td><code>*</code></td>
            <td>Fill color. Defaults to the value of the <a href="#path-color"><code>color</code></a> option</td>
        </tr>
        <tr id="path-fillopacity">
            <td><code><b>fillOpacity</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.2</code></td>
            <td>Fill opacity.</td>
        </tr>
        <tr id="path-fillrule">
            <td><code><b>fillRule</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;evenodd&#x27;</code></td>
            <td>A string that defines
                <a href="https://developer.mozilla.org/docs/Web/SVG/Attribute/fill-rule">how the inside
                of a shape</a> is determined.</td>
        </tr>
        <tr id="path-interactive">
            <td><code><b>interactive</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>If <code>false</code>, the vector will not emit mouse events and will
                act as a part of the underlying map.</td>
        </tr>
        <tr id="path-renderer">
            <td><code><b>renderer</b></code></td>
            <td><code><a href="/doc/maps/en/manual/base-classes#dgrenderer">Renderer</a></code></td>
            <td><code></code></td>
            <td>Use this specific instance of <a href="/doc/maps/en/manual/base-classes#dgrenderer"><code>Renderer</code></a> for this path. Takes
                precedence over the map&#39;s <a href="/doc/maps/en/manual/map#map-renderer">default renderer</a>.</td>
        </tr>
        <tr id="path-classname">
            <td><code><b>className</b></code></td>
            <td><code>string </code></td>
            <td><code>null</code></td>
            <td>Custom class name set on an element. Only for SVG renderer.</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Methods

<table id="dgpath-methods">
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="path-redraw">
            <td><code><b>redraw</b>()</code></td>
            <td><code>this</code></td>
            <td>Redraws the layer. Sometimes useful after you changed the coordinates that the path uses.</td>
        </tr>
        <tr id="path-setstyle">
            <td><code>
                <b>setStyle</b>(
                <nobr>&lt;<a href="#dgpath-options">Path options</a>&gt; <i>style</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Changes the appearance of a Path based on the options in the <a href="#dgpath-options">
                <code>Path options</code></a> object.</td>
        </tr>
        <tr id="path-bringtofront">
            <td><code><b>bringToFront</b>()</code></td>
            <td><code>this</code></td>
            <td>Brings the layer to the top of all path layers.</td>
        </tr>
        <tr id="path-bringtoback">
            <td><code><b>bringToBack</b>()</code></td>
            <td><code>this</code></td>
            <td>Brings the layer to the bottom of all path layers. </td>
        </tr>
    </tbody>
</table>

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.Polyline

A class for drawing polyline overlays on a map. Extends <a href="#dgpath">Path</a>.

#### Usage example

    // create a red polyline from an array of LatLng points
    var latlngs = [
        [-122.68, 45.51],
        [-122.43, 37.77],
        [-118.2, 34.04]
    ];
    var polyline = DG.polyline(latlngs, {color: 'red'}).addTo(map);
    // zoom the map to the polyline
    map.fitBounds(polyline.getBounds());

You can also pass a multi-dimensional array to represent a MultiPolyline shape:

    // create a red polyline from an array of arrays of LatLng points
    var latlngs = [
        [[-122.68, 45.51],
         [-122.43, 37.77],
         [-118.2, 34.04]],
        [[-73.91, 40.78],
         [-87.62, 41.83],
         [-96.72, 32.76]]
    ];

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="polyline-l-polyline">
            <td><code><b>DG.polyline</b>(
                <nobr>&lt;LatLng[]&gt; <i>latlngs</i></nobr>,
                <nobr>&lt;<a href="#dgpath-options">Path options</a>&gt; <i>options?</i>)</nobr>
            </code></td>
            <td>Instantiates a polyline object given an array of geographical points and
                optionally an options object. You can create a <a href="#dgpolyline"><code>Polyline</code></a>
                object with multiple separate lines (<code>MultiPolyline</code>) by passing an array of arrays
                of geographic points.</td>
        </tr>
    </tbody>
</table>

#### Options

<table id="dgpolyline-options">
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="polyline-smoothfactor">
            <td><code><b>smoothFactor</b></code></td>
            <td><code>Number </code>
            <td><code>1.0</code></td>
            <td>How much to simplify the polyline on each zoom level. More means
                better performance and smoother look, and less means more accurate representation.</td>
        </tr>
        <tr id="polyline-noclip">
            <td><code><b>noClip</b></code></td>
            <td><code>Boolean: false</code>
            <td><code></code></td>
            <td>Disable polyline clipping.</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="#dgpath-options">Path</a> <!-- TODO: include options -->

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Methods

<table id="dgpolyline-methods">
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="polyline-togeojson">
            <td><code><b>toGeoJSON</b>()</code></td>
            <td><code>Object</code></td>
            <td>Returns a <a href="http://en.wikipedia.org/wiki/GeoJSON">
                <code>GeoJSON</code></a> representation of the polyline
                (as a GeoJSON <code>LineString</code> or <code>MultiLineString</code> Feature).</td>
        </tr>
        <tr id="polyline-getlatlngs">
            <td><code><b>getLatLngs</b>()</code></td>
            <td><code>LatLng[]</code></td>
            <td>Returns an array of the points in the path, or nested arrays of points in case of multi-polyline.</td>
        </tr>
        <tr id="polyline-setlatlngs">
            <td><code><b>setLatLngs</b>(<nobr>&lt;LatLng[]&gt; <i>latlngs</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Replaces all the points in the polyline with the given array of geographical points.</td>
        </tr>
        <tr id="polyline-isempty">
            <td><code><b>isEmpty</b>()</code></td>
            <td><code>Boolean</code></td>
            <td>Returns <code>true</code> if the Polyline has no LatLngs.</td>
        </tr>
        <tr id="polyline-getcenter">
            <td><code><b>getCenter</b>()</code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Returns the center (<a href="http://en.wikipedia.org/wiki/Centroid">centroid</a>) of the
            polyline.</td>
        </tr>
        <tr id="polyline-getbounds">
            <td><code><b>getBounds</b>()</code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlngbounds">LatLngBounds</a></code></td>
            <td>Returns the <a href="/doc/maps/en/manual/basic-types#dglatlngbounds"><code>LatLngBounds</code></a> of the path.</td>
        </tr>
        <tr id="polyline-addlatlng">
            <td><code><b>addLatLng</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>
                    Adds a given point to the polyline. By default, adds to the first ring of
                    the polyline in case of a multi-polyline, but can be overridden by passing
                    a specific ring as a LatLng array (that you can earlier access with
                    <a href="#polyline-getlatlngs"><code>getLatLngs</code></a>).
                </td>
        </tr>
    </tbody>
</table>

Methods inherited from <a href="#dgpath-methods">Path</a> <!-- TODO: include methods -->

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.Polygon

A class for drawing polygon overlays on a map. Extends <a href="#dgpolyline">Polyline</a>.
Note that points you pass when creating a polygon shouldn't have an additional last point equal
to the first one — it's better to filter out such points.

#### Usage example

    // create a red polygon from an array of LatLng points
    var latlngs = [[-111.03, 41],[-111.04, 45],[-104.05, 45],[-104.05, 41]];
    var polygon = DG.polygon(latlngs, {color: 'red'}).addTo(map);
    // zoom the map to the polygon
    map.fitBounds(polygon.getBounds());

You can also pass an array of arrays of latlngs, with the first array representing the outer shape
and the other arrays representing holes in the outer shape:

    var latlngs = [
      [[-111.03, 41],[-111.04, 45],[-104.05, 45],[-104.05, 41]], // outer ring
      [[-108.58,37.29],[-108.58,40.71],[-102.50,40.71],[-102.50,37.29]] // hole
    ];

Additionally, you can pass a multi-dimensional array to represent a MultiPolygon shape.

    var latlngs = [
      [ // first polygon
        [[-111.03, 41],[-111.04, 45],[-104.05, 45],[-104.05, 41]], // outer ring
        [[-108.58,37.29],[-108.58,40.71],[-102.50,40.71],[-102.50,37.29]] // hole
      ],
      [ // second polygon
        [[-109.05, 37],[-109.03, 41],[-102.05, 41],[-102.04, 37],[-109.05, 38]]
      ]
    ];

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="polygon-l-polygon">
            <td><code>
                <b>DG.polygon</b>(
                <nobr>&lt;LatLng[]&gt; <i>latlngs</i></nobr>,
                <nobr>&lt;Polyline options&gt; <i>options?</i>)</nobr>
            </code></td>
            <td></td>
        </tr>
    </tbody>
</table>


#### Options

Options inherited from <a href="#dgpolyline-options">Polyline</a> <!-- TODO: include options -->

Options inherited from <a href="#dgpath-options">Path</a> <!-- TODO: include options -->

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Methods

<span id="#dgpolygon-methods"></span>

Methods inherited from <a href="#dgpolyline-methods">Polyline</a> <!-- TODO: include methods -->

Methods inherited from <a href="#dgpath-methods">Path</a> <!-- TODO: include methods -->

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.Rectangle

A class for drawing rectangle overlays on a map. Extends <a href="#dgpolygon">Polygon</a>.

#### Usage example

    // define rectangle geographical bounds
    var bounds = [[54.559322, -5.767822], [56.1210604, -3.021240]];
    // create an orange rectangle
    DG.rectangle(bounds, {color: "#ff7800", weight: 1}).addTo(map);
    // zoom the map to the rectangle bounds
    map.fitBounds(bounds);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="rectangle-l-rectangle">
            <td><code>
                <b>DG.rectangle</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>latLngBounds</i></nobr>,
                <nobr>&lt;Polyline options&gt; <i>options?</i>)</nobr>
            </code></td>
            <td></td>
        </tr>
    </tbody>
</table>

#### Options

Options inherited from <a href="#dgpolyline-options">Polyline</a> <!-- TODO: include options -->

Options inherited from <a href="#dgpath-options">Path</a> <!-- TODO: include options -->

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="rectangle-setbounds">
            <td><code><b>setBounds</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>latLngBounds</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Redraws the rectangle with the passed bounds.</td>
        </tr>
    </tbody>
</table>

Methods inherited from <a href="#dgpolygon-method">Polygon</a> <!-- TODO: include methods -->

Methods inherited from <a href="#dgpath-methods">Path</a> <!-- TODO: include methods -->

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.Circle

A class for drawing circle overlays on a map. Extends <a href="#dgcirclemarker">CircleMarker</a>. It's an approximation
and starts to diverge from a real circle closer to poles (due to projection distortion).

#### Usage example

    DG.circle([50.5, 30.5], 200).addTo(map);

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circle-l-circle">
            <td><code>
                <b>DG.circle</b>(
                    <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;<a href="#dgpath-options">Path options</a>&gt; <i>options?</i>)</nobr>
            </code></td>
            <td>Instantiates a circle object given a geographical point, and an options object
                which contains the circle radius.</td>
        </tr>
        <tr id="circle-l-circle-2">
            <td><code><b>DG.circle</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                <nobr>&lt;Number&gt; <i>radius</i></nobr>,
                <nobr>&lt;<a href="#dgpath-options">Path options</a>&gt; <i>options?</i>)</nobr>
            </code></td>
            <td>Obsolete way of instantiating a circle, for compatibility with old code.
                Do not use in new applications or plugins.</td>
        </tr>
    </tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circle-radius">
            <td><code><b>radius</b></code></td>
            <td><code>Number</code>
            <td><code></code></td>
            <td>Radius of the circle, in meters.</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="#dgpath-options">Path</a> <!-- TODO: include options -->

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Methods

<table>
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circle-setradius">
            <td><code>
                <b>setRadius</b>(
                <nobr>&lt;Number&gt; <i>radius</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Sets the radius of a circle. Units are in meters.</td>
        </tr>
        <tr id="circle-getradius">
            <td><code><b>getRadius</b>()</code></td>
            <td><code>Number</code></td>
            <td>Returns the current radius of a circle. Units are in meters.</td>
        </tr>
        <tr id="circle-getbounds">
            <td><code><b>getBounds</b>()</code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlngbounds">LatLngBounds</a></code></td>
            <td>Returns the <a href="/doc/maps/en/manual/basic-types#dglatlngbounds"><code>LatLngBounds</code></a>
                of the path.</td>
        </tr>
    </tbody>
</table>

Methods inherited from <a href="#dgcirclemarker-methods">CircleMarker</a> <!-- TODO: include methods -->

Methods inherited from <a href="#dgpath-methods">Path</a> <!-- TODO: include methods -->

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.CircleMarker

A circle of a fixed size with radius specified in pixels. Extends <a href="#dgpath">Path</a>.

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circlemarker-dg-circlemarker">
            <td><code>
                <b>DG.circleMarker</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                <i>options</i>)</code></td>
            <td>Instantiates a circle marker object given a geographical point, and an optional options object.</td>
        </tr>
    </tbody>
</table>

#### Options

<table>
    <thead>
        <tr>
            <th>Option</th>
            <th>Type</th>
            <th>Default</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circlemarker-radius">
            <td><code><b>radius</b></code></td>
            <td><code>Number </code></td>
            <td><code>10</code></td>
            <td>Radius of the circle marker, in pixels</td>
        </tr>
    </tbody>
</table>

Options inherited from <a href="#dgpath-options">Path</a> <!-- TODO: include options -->

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->


#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Methods

<table id="dgcirclemarker-methods">
    <thead>
        <tr>
            <th>Method</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circlemarker-togeojson">
            <td><code><b>toGeoJSON</b>()</code></td>
            <td><code>Object</code></td>
            <td>
                    Returns a <a href="http://en.wikipedia.org/wiki/GeoJSON"><code>GeoJSON</code></a>
                    representation of the circle marker (as a GeoJSON <a href="/doc/maps/en/manual/basic-types#point"><code>Point</code></a>
                    Feature).
                </td>
        </tr>
        <tr id="circlemarker-setlatlng">
            <td><code><b>setLatLng</b>(
                <nobr>&lt;<a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latLng</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Sets the position of a circle marker to a new location. </td>
        </tr>
        <tr id="circlemarker-getlatlng">
            <td><code><b>getLatLng</b>()</code></td>
            <td><code><a href="/doc/maps/en/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Returns the current geographical position of the circle marker </td>
        </tr>
        <tr id="circlemarker-setradius">
            <td><code><b>setRadius</b>(<nobr>&lt;Number&gt; <i>radius</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Sets the radius of a circle marker. Units are in pixels. </td>
        </tr>
        <tr id="circlemarker-getradius">
            <td><code><b>getRadius</b>()</code></td>
            <td><code>Number</code></td>
            <td>Returns the current radius of the circle </td>
        </tr>
    </tbody>
</table>

Methods inherited from <a href="#dgpath-methods">Path</a> <!-- TODO: include methods -->

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->


### DG.Svg

Allows vector layers to be displayed with <a href="https://developer.mozilla.org/docs/Web/SVG">SVG</a>.
Inherits <a href="/doc/maps/en/manual/base-classes#dgrenderer">Renderer</a>.

Due to <a href="http://caniuse.com/#search=svg">technical limitations</a>, SVG is not
available in all web browsers, notably Android 2.x and 3.x.

Although SVG is not available on IE8, this browser supports
<a href="https://en.wikipedia.org/wiki/Vector_Markup_Language">VML</a>
(a now deprecated technology), and the SVG renderer will fall back to VML in
this case.


#### Usage example

Use SVG by default for all paths in the map:

    var map = DG.map("map", {
        renderer: DG.svg();
    });

Use a SVG renderer with extra padding for specific vector geometries:

    var map = DG.map("map");
    var myRenderer = DG.svg({ padding: 0.5 });
    var line = DG.polyline( coordinates, { renderer: myRenderer } );
    var circle = DG.circle( center, { renderer: myRenderer } );

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="svg-dg-svg">
            <td><code><b>DG.svg</b>(<nobr>&lt;SVG options&gt; <i>options?</i>)</nobr></code></td>
            <td>Creates a SVG renderer with the given options.</td>
        </tr>
    </tbody>
</table>

#### Options

Options inherited from <a href="/doc/maps/en/manual/base-classes#dgrenderer-options">Renderer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Methods

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

#### Functions

There are several static functions which can be called without instantiating DG.SVG:

<table>
    <thead>
        <tr>
            <th>Function</th>
            <th>Returns</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="svg-create">
            <td><code><b>create</b>(<nobr>&lt;String&gt; <i>name</i>)</nobr></code></td>
            <td><code>SVGElement</code></td>
            <td>Returns a instance of <a href="https://developer.mozilla.org/docs/Web/API/SVGElement">SVGElement</a>,
                corresponding to the class name passed. For example, using &#39;line&#39; will return
                an instance of <a href="https://developer.mozilla.org/docs/Web/API/SVGLineElement">SVGLineElement</a>.</td>
        </tr>
        <tr id="svg-pointstopath">
            <td><code>
                <b>pointsToPath</b>(
                <nobr>&lt;[]&gt; <i>rings</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>closed</i>)</nobr>
            </code></td>
            <td><code>String</code></td>
            <td>Generates a SVG path string for multiple rings, with each ring turning
                into &quot;M..L..L..&quot; instructions</td>
        </tr>
    </tbody>
</table>

### DG.Canvas

Allows vector layers to be displayed with <a href="https://developer.mozilla.org/docs/Web/API/Canvas_API">canvas</a>.
Inherits <a href="/doc/maps/en/manual/base-classes#dgrenderer"><code>Renderer</code></a>.
Inherits <a href="/doc/maps/en/manual/base-classes#dgrenderer">Renderer</a>.
Due to <a href="http://caniuse.com/#search=canvas">technical limitations</a>, Canvas is not
available in all web browsers, notably IE8, and overlapping geometries might
not display properly in some edge cases.

#### Usage example

Use Canvas by default for all paths in the map:

    var map = DG.map('map', {
        renderer: DG.canvas();
    });

Use a Canvas renderer with extra padding for specific vector geometries:

    var map = DG.map('map');
    var myRenderer = DG.canvas({ padding: 0.5 });
    var line = DG.polyline( coordinates, { renderer: myRenderer } );
    var circle = DG.circle( center, { renderer: myRenderer } );

#### Creation

<table>
    <thead>
        <tr>
            <th>Factory</th>
            <th>Description</th>
        </tr>
	</thead>
    <tbody>
        <tr id="canvas-dg-canvas">
            <td><code><b>DG.canvas</b>(<nobr>&lt;Canvas options&gt; <i>options?</i>)</nobr></code></td>
            <td>Creates a Canvas renderer with the given options.</td>
        </tr>
    </tbody>
</table>

#### Options

Options inherited from <a href="/doc/maps/en/manual/base-classes#dgrenderer-options">Renderer</a> <!-- TODO: include options -->

Options inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### Events

Events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

Popup events inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Methods

Popup methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Methods inherited from <a href="/doc/maps/en/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/en/quickstart/quickstart.md
================================================
## All capabilities of 2GIS API&SDK
[dev.2gis.com](https://dev.2gis.com/)

## Full updated documentation
[docs.2gis.com/en](https://docs.2gis.com/en)


## General information

With maps API you can:

* <span style="color:323232">create interactive maps on the web page;</span>
* <span style="color:323232">display various objects on the map (markers, pop-ups, geometric objects);</span>
* <span style="color:323232">search on the map: to determine the coordinates of geoobjects by their names and the names by the coordinates.</span>

The source code of the maps API is available on [GitHub](https://github.com/2gis/mapsapi), the project is open to suggestions and pull-requests.

### Getting started

The following is a simple example of creating a map.

#### Connect API

To connect API JavaScript code, add the following code to the head section of the HTML page:

    <script src="https://maps.api.2gis.ru/2.0/loader.js?pkg=full"></script>

If you are interested in including the API code using npm, go to the [Connection API](/doc/maps/en/manual/dg-loading#npm) section.

#### Create a map container

To create a container in which the map will be displayed, you must add a block HTML element of the required size:

    <body>
        <div id="map" style="width:500px; height:400px"></div>
    </body>


#### Create map

Now everything is prepared for the map creation. To do this, add the following code to the head section:

    <script type="text/javascript">
        var map;

        DG.then(function () {
            map = DG.map('map', {
                center: [54.98, 82.89],
                zoom: 13
            });
        });
    </script>

In this example map takes two parameters:

* <span style="color:323232">center - the coordinates of the center of the map in the following format [latitude, longitude];</span>
* <span style="color:323232">zoom - the scale factor in the range from 1 to 18.</span>

#### Add marker to the map

After creating the map you can display a marker on it by adding one line of the code to the previously written one:

    <script type="text/javascript">
        var map;

        DG.then(function () {
            map = DG.map('map', {
                center: [54.98, 82.89],
                zoom: 13
            });

            DG.marker([54.98, 82.89]).addTo(map);
        });
    </script>

#### Show pop-up with information

If to extend a little the above added string of the code with a marker, then when clicking on the marker, a popup
will be displayed (pop up block) with the information you need:

    <script type="text/javascript">
        var map;

        DG.then(function () {
            map = DG.map('map', {
                center: [54.98, 82.89],
                zoom: 13
            });

            DG.marker([54.98, 82.89]).addTo(map).bindPopup('You've clicked on me!');
        });
    </script>

#### All together

Resulting code:

    <!DOCTYPE html>
    <html>
        <head>
            <title>API карт 2ГИС</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js?pkg=full"></script>
            <script type="text/javascript">
                var map;

                DG.then(function () {
                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    DG.marker([54.98, 82.89]).addTo(map).bindPopup('You have clicked on me!');
                });
            </script>
        </head>
        <body>
            <div id="map" style="width:500px; height:400px"></div>
        </body>
    </html>

### Further steps

Was everything successful? Now you can see the <a href="/doc/maps/en/manual/dg-loading">developer guide</a>
and <a href="/doc/maps/en/examples/base">examples of use</a>.

### Technical support

If you have any difficulties in working with the maps API &mdash;
<a href="mailto:api@2gis.ru">email us</a> and we will help you to solve the problem.


================================================
FILE: src/doc/ru/examples/base.md
================================================
## Базовое использование

{toc}

### Описание

Ниже приведены примеры базового использования карты. Для получения подробной информации о работе с картой воспользуйтесь
разделами документации <a href="/doc/maps/ru/manual/dg-loading">Подключение API</a> и <a href="/doc/maps/ru/manual/map">Карта</a>.

### Создание карты

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        DG.map('map', {
            center: [54.98, 82.89],
            zoom: 13
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Создание карты</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });
                });
            </script>
        </body>
    </html>

### Создание карты по требованию

Инициализация карты по требованию (удобно при отображении карты во всплывающем окне):
<input id="create" type="button" value="Показать карту" />
<div id="mapBlock"></div>
<script>
    var createButton = document.getElementById('create');

    createButton.onclick = function() {
        var container = document.createElement('div'),
            mapBlock = document.getElementById('mapBlock');

        container.id = 'map1';
        container.style.width = '100%';
        container.style.height = '400px';
        mapBlock.appendChild(container);

        DG.then(function(){
            DG.map('map1', {
                center: [54.98, 82.89],
                zoom: 13
            });
        });

        createButton.onclick = null;
    }
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Создание карты по требованию</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js?lazy=true"></script>
        </head>
        <body>
            <input id="create" type="button" value="Показать карту" />
            <div id="mapBlock"></div>
            <script>
                var createButton = document.getElementById('create');

                createButton.onclick = function() {
                    var container = document.createElement('div'),
                        mapBlock = document.getElementById('mapBlock');

                    container.id = 'map';
                    container.style.width = '100%';
                    container.style.height = '400px';
                    mapBlock.appendChild(container);

                    DG.then(function(){
                        DG.map('map', {
                            center: [54.98, 82.89],
                            zoom: 13
                        });
                    });
                }
            </script>
        </body>
    </html>

### Использование опций подключения

Ниже представлен пример вызова карты с таким набором опций: <code>pkg=basic</code>, <code>skin=light</code>. Как
результат мы получим сборку с базовой функциональностью в светлой теме. Все возможные опции можно посмотреть в разделе
<a href="/doc/maps/ru/manual/dg-loading#опцииподключения">Опции подключения</a>.

    <!DOCTYPE html>
    <html>
        <head>
            <title>Использование опций подключения</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js?pkg=basic&skin=light"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });
                });
            </script>
        </body>
    </html>

### Изменение размера карты

При клике на кнопку изменяется размер контейнера и карта подстраивается под новый размер:
<input id="changeSize" type="button" value="Изменить размер" />
<div id="map3" style="width: 100%; height: 200px;"></div>
<script>
    var changeSizeButton = document.getElementById('changeSize');

    DG.then(function() {
        var map,
            enabled = false;

        map = DG.map('map3', {
            center: [54.98, 82.89],
            zoom: 15,
            animate: true
        });

        changeSizeButton.onclick = function() {
            var mapDiv = document.getElementById('map3');
            mapDiv.style.height = (enabled ? '200' : '400') + 'px';
            enabled = !enabled;
            map.invalidateSize();
        }
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Изменение размера карты</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <input id="changeSize" type="button" value="Изменить размер" />
            <div id="map" style="width: 100%; height: 200px;"></div>
            <script>
                var changeSizeButton = document.getElementById('changeSize');

                DG.then(function() {
                    var map,
                        enabled = false;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 15,
                        animate: true
                    });

                    changeSizeButton.onclick = function() {
                        var mapDiv = document.getElementById('map');
                        mapDiv.style.height = (enabled ? '200' : '400') + 'px';
                        // обновление карты
                        map.invalidateSize();
                    }
                });
            </script>
        </body>
    </html>

### Отключение опций взаимодействия

Пример отображения статической карты:

<div id="map4" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        DG.map('map4', {
            center: [54.98, 82.89],
            zoom: 13,
            dragging : false,
            touchZoom: false,
            scrollWheelZoom: false,
            doubleClickZoom: false,
            boxZoom: false,
            geoclicker: false,
            zoomControl: false,
            fullscreenControl: false
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Отключение опций взаимодействия</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13,
                        dragging : false,
                        touchZoom: false,
                        scrollWheelZoom: false,
                        doubleClickZoom: false,
                        boxZoom: false,
                        geoclicker: false,
                        zoomControl: false,
                        fullscreenControl: false
                    });
                });
            </script>
        </body>
    </html>

### Определение местоположения пользователя

Пример определения географического расположения пользователя:

<div id="map5" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map;

        map = DG.map('map5', {
            center: [54.98, 82.89],
            zoom: 13
        });

        map.locate({setView: true, watch: true})
            .on('locationfound', function(e) {
                DG.marker([e.latitude, e.longitude]).addTo(map);
            })
            .on('locationerror', function(e) {
                DG.popup()
                  .setLatLng(map.getCenter())
                  .setContent('Доступ к определению местоположения отключён')
                  .openOn(map);
            });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Определение местоположения пользователя</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    map.locate({setView: true, watch: true})
                        .on('locationfound', function(e) {
                            DG.marker([e.latitude, e.longitude]).addTo(map);
                        })
                        .on('locationerror', function(e) {
                            DG.popup()
                              .setLatLng(map.getCenter())
                              .setContent('Доступ к определению местоположения отключён')
                              .openOn(map);
                        });
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/ru/examples/bounds.md
================================================
## Работа с границами карты

{toc}

### Описание

Ниже приведены примеры ограничения границ карты и уровней масштабирования. Для получения подробной информации о работе
с картой воспользуйтесь разделом документации <a href="/doc/maps/ru/manual/map">Карта</a>.

### Ограничение границ и масштаба

Ограничение просматриваемой области границами города Новосибирск, а также уровней масштабирования диапазоном от 10 до 15:

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        DG.map('map', {
            center: [54.98, 82.89],
            zoom: 10,
            maxBounds: [
                [54.8220, 82.4304],
                [55.1372, 83.3505]
            ],
            minZoom: 10,
            maxZoom: 15
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Ограничение границ и масштаба</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 10,
                        maxBounds: [
                            [54.8220, 82.4304],
                            [55.1372, 83.3505]
                        ],
                        minZoom: 10,
                        maxZoom: 15
                    });
                });
            </script>
        </body>
    </html>

<!--
### Карта с панелью

После инициализации карты её центр подстраивается таким образом, чтобы центр Москвы был посередине видимой области
(с учетом левой панели):

<style>
    #container {
        height:400px;
        position: relative;
    }
    #content {
        position: absolute;
        background:#000;
        background:rgba(51,51,51,.9);
        width:200px;
        height: 400px;
        z-index: 1000;
    }
</style>
<div id='container'>
    <div id='content'></div>
    <div id="map1" style="width: 100%; height: 400px;"></div>
</div>
<script>
    DG.then(function() {
        var map;
        map = DG.map('map1', {
            center: [55.753559, 37.609218],
            zoom: 10,
            zoomControl: false,
            fullscreenControl: false
        });
        DG.control.zoom({position: 'topright'}).addTo(map);
        map.fitBounds(map.getBounds(), {
            paddingTopLeft: [200, 0]
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Карта с левой панелью</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
            <style>
                #container {
                    height:400px;
                    position: relative;
                }
                #content {
                    position: absolute;
                    background:#000;
                    background:rgba(51,51,51,.9);
                    width:200px;
                    height: 400px;
                    z-index: 1000;
                }
            </style>
        </head>
        <body>
            <div id='container'>
                <div id='content'></div>
                <div id="map" style="width: 100%; height: 400px;"></div>
            </div>
            <script>
                DG.then(function() {
                    var map;
                    map = DG.map('map', {
                        center: [55.753559, 37.609218],
                        zoom: 10,
                        zoomControl: false,
                        fullscreenControl: false
                    });
                    DG.control.zoom({position: 'topright'}).addTo(map);
                    map.fitBounds(map.getBounds(), {
                        paddingTopLeft: [200, 0]
                    });
                });
            </script>
        </body>
    </html>
-->


================================================
FILE: src/doc/ru/examples/controls.md
================================================
## Элементы управления

{toc}

### Описание

Ниже приведены примеры добавления, размещения и работы с элементами управления. Для получения подробной информации о работе
с элементами управления воспользуйтесь разделом документации <a href="/doc/maps/ru/manual/controls">Элементы управления</a>.

### Скрытие элементов управления по умолчанию

Если необходимо получить "чистую" карту, без лишних элементов управления, тогда вам поможет следующий пример:

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map', {
            center: [54.98, 82.89],
            zoom: 13,
            fullscreenControl: false,
            zoomControl: false
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Скрытие элементов управления по умолчанию</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13,
                        fullscreenControl: false,
                        zoomControl: false
                    });
                });
            </script>
        </body>
    </html>

### Отображение элементов управления в разных частях карты

<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map1', {
            center: [54.98, 82.89],
            zoom: 13
        });

        DG.control.location({position: 'bottomright'}).addTo(map);
        DG.control.scale().addTo(map);
        DG.control.ruler({position: 'bottomleft'}).addTo(map);
        DG.control.traffic().addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Отображение элементов управления в разных частях карты</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    DG.control.location({position: 'bottomright'}).addTo(map);
                    DG.control.scale().addTo(map);
                    DG.control.ruler({position: 'bottomleft'}).addTo(map);
                    DG.control.traffic().addTo(map);
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/ru/examples/events.md
================================================
## Обработка событий

{toc}

### Описание

Ниже приведены примеры работы с событиями. Для получения подробной информации перейдите в разделы документации
<a href="/doc/maps/ru/manual/base-classes#dgevented">DG.Evented</a> и <a href="/doc/maps/ru/manual/base-classes#events">Events</a>.

### Подписка на события

Пример подписки на различные события (клик в маркер, карту, геометрию):

Вы кликнули в: <span id="clicked_element">никуда</span>
<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            clickedElement = document.getElementById('clicked_element'),
            coords = [
                [54.99, 82.88],
                [54.985, 82.94],
                [54.984, 82.925],
                [54.981, 82.928]
            ];

        map = DG.map('map', {
            center: [54.98, 82.89],
            zoom: 13
        });

        map.on('click', function(e) {
            clickedElement.innerHTML = 'карту, координаты ' + e.latlng.lat + ', ' + e.latlng.lng;
        });

        DG.marker([54.98, 82.89])
            .on('click', function() {
                clickedElement.innerHTML = 'маркер';
            })
            .addTo(map);

        DG.polygon(coords)
            .on('click', function() {
                clickedElement.innerHTML = 'многоугольник';
            })
            .addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Подписка на события</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            Вы кликнули в: <span id="clicked_element">никуда</span>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        clickedElement = document.getElementById('clicked_element'),
                        coords = [
                            [54.99, 82.88],
                            [54.985, 82.94],
                            [54.984, 82.925],
                            [54.981, 82.928]
                        ];

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    map.on('click', function(e) {
                        clickedElement.innerHTML = 'карту, координаты ' + e.latlng.lat + ', ' + e.latlng.lng;
                    });

                    DG.marker([54.98, 82.89])
                        .on('click', function() {
                            clickedElement.innerHTML = 'маркер';
                        })
                        .addTo(map);

                    DG.polygon(coords)
                        .on('click', function() {
                            clickedElement.innerHTML = 'многоугольник';
                        })
                        .addTo(map);
                });
            </script>
        </body>
    </html>

### Подписка на изменение проекта 2ГИС

При изменении <a href="/doc/maps/ru/manual/map#map-projectdetector">проекта</a>, выделяются границы текущего:

<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map, currentProjectBound;

        map = DG.map('map1', {
            center: DG.latLng(54.98, 82.89),
            zoom: 9
        });

        // подписываемся на событие изменения текущего проекта 2GIS
        map.on('projectchange', function(e) {
            var bounds = e.getProject().bound;
            currentProjectBound = DG.geoJSON(bounds, {
                color:"#f03",
                weight:1
            }).addTo(map);
        });

        // подписываемся на событие выхода из проекта 2GIS
        map.on('projectleave', function(e) {
            if (currentProjectBound) {
                map.removeLayer(currentProjectBound);
            }
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Подписка на изменение проекта 2ГИС</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map, currentProjectBound;

                    map = DG.map('map', {
                        center: DG.latLng(54.98, 82.89),
                        zoom: 9
                    });

                    // подписываемся на событие изменения текущего проекта 2GIS
                    map.on('projectchange', function(e) {
                        var bounds = e.getProject().bound;
                        currentProjectBound = DG.geoJSON(bounds, {
                            color:"#f03",
                            weight:1
                        }).addTo(map);
                    });

                    // подписываемся на событие выхода из проекта 2GIS
                    map.on('projectleave', function(e) {
                        if (currentProjectBound) {
                            map.removeLayer(currentProjectBound);
                        }
                    });
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/ru/examples/external-modules.md
================================================
## Внешние модули

{toc}

### Описание

Ниже приведены примеры подключения и использования внешних модулей. Для получения подробной информации перейдите
в раздел документации <a href="/doc/maps/ru/manual/dg-external-modules">Внешние модули</a>.

### Кластеризатор

Пример подключения кластеризатора. Кластеризатор часто используется для отображения большого количества маркеров.
Код модуля и его документация доступна в <a href="https://github.com/Leaflet/Leaflet.markercluster" target="_blank">GitHub-репозитории</a> автора.

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<link rel="stylesheet" href="https://unpkg.com/leaflet.markercluster@1.4.1/dist/MarkerCluster.css" />
<link rel="stylesheet" href="https://unpkg.com/leaflet.markercluster@1.4.1/dist/MarkerCluster.Default.css" />
<script src="https://maps.api.2gis.ru/2.0/cluster_realworld.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        // загрузка кода модуля
        return DG.plugin('https://unpkg.com/leaflet.markercluster@1.4.1/dist/leaflet.markercluster.js');
    }).then(function() {
        map = DG.map('map', {
            center: DG.latLng(54.92, 82.82),
            zoom: 9
        });

        var markers = DG.markerClusterGroup();

        for (var i = 0; i < addressPoints.length; i++) {
            var a = addressPoints[i];
            var title = a[2];
            var marker = DG.marker([a[0], a[1]], { title: title });
            marker.bindPopup(title);
            markers.addLayer(marker);
        }

        map.addLayer(markers);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Кластеризатор</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
            <link rel="stylesheet" href="https://unpkg.com/leaflet.markercluster@1.4.1/dist/MarkerCluster.css" />
            <link rel="stylesheet" href="https://unpkg.com/leaflet.markercluster@1.4.1/dist/MarkerCluster.Default.css" />
            <script src="https://maps.api.2gis.ru/2.0/cluster_realworld.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    // загрузка кода модуля
                    return DG.plugin('https://unpkg.com/leaflet.markercluster@1.4.1/dist/leaflet.markercluster.js');
                }).then(function() {
                    map = DG.map('map', {
                        center: DG.latLng(54.92, 82.82),
                        zoom: 9
                    });

                    var markers = DG.markerClusterGroup();

                    // обработка координат для установки маркеров
                    for (var i = 0; i < addressPoints.length; i++) {
                        var a = addressPoints[i];
                        var title = a[2];
                        var marker = DG.marker([a[0], a[1]], { title: title });
                        marker.bindPopup(title);
                        markers.addLayer(marker);
                    }

                    map.addLayer(markers);
                });
            </script>
        </body>
    </html>


### Тепловая карта

Пример подключения тепловой карты. Тепловая карта позволяет визуализировать количественные данные в зависимости
от географического региона. Интенсивность окраски каждого региона зависит от соответствующих ему значений.

<script src="https://maps.api.2gis.ru/2.0/heat_realworld.js"></script>
<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        // загрузка кода модуля
        return DG.plugin('https://unpkg.com/leaflet.heat@0.2.0/dist/leaflet-heat.js');
    }).then(function() {
        map = DG.map('map1', {
            center: DG.latLng(54.89, 82.45),
            zoom: 10
        });

        DG.heatLayer(addressPoints1).addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Тепловая карта</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
            <script src="https://maps.api.2gis.ru/2.0/heat_realworld.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    // загрузка кода модуля
                    return DG.plugin('https://unpkg.com/leaflet.heat@0.2.0/dist/leaflet-heat.js');
                }).then(function() {
                    map = DG.map('map', {
                        center: DG.latLng(54.89, 82.45),
                        zoom: 10
                    });

                    DG.heatLayer(addressPoints1).addTo(map);
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/ru/examples/geojson.md
================================================
## Работа с GeoJSON

{toc}

### Описание

Ниже приведен пример работы с GeoJSON. Для получения подробной информации перейдите в раздел документации
<a href="/doc/maps/ru/manual/other-layers#dggeojson">GeoJSON</a>.

### Пример использования

Отображение объектов, описанных в формате GeoJSON:

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map', {
            center: [55.042136, 82.91699],
            zoom: 16
        });

        var data = [
            {
                "type": "Feature",
                "properties": {
                    "info": "Я маркер"
                },
                "geometry": {
                    "type": "Point",
                    "coordinates": [82.91799, 55.043136]
                }
            },
            {
                "type": "Feature",
                "properties": {
                    "info": "Я полигон"
                },
                "geometry": {
                    "type": "Polygon",
                    "coordinates": [
                        [
                            [82.91699, 55.042136],
                            [82.917522, 55.040187],
                            [82.918063, 55.040235],
                            [82.917540, 55.042184],
                            [82.91699, 55.042136]
                        ]
                    ]
                }
            }
        ];

        DG.geoJson(data, {
            onEachFeature: function (feature, layer) {
                layer.bindPopup(feature.properties.info);
            }
        }).addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>GeoJSON</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [55.042136, 82.91699],
                        zoom: 16
                    });

                    var data = [
                        {
                            "type": "Feature",
                            "properties": {
                                "info": "Я маркер"
                            },
                            "geometry": {
                                "type": "Point",
                                "coordinates": [82.91799, 55.043136]
                            }
                        },
                        {
                            "type": "Feature",
                            "properties": {
                                "info": "Я полигон"
                            },
                            "geometry": {
                                "type": "Polygon",
                                "coordinates": [
                                    [
                                        [82.91699, 55.042136],
                                        [82.917522, 55.040187],
                                        [82.918063, 55.040235],
                                        [82.917540, 55.042184],
                                        [82.91699, 55.042136]
                                    ]
                                ]
                            }
                        }
                    ];

                    DG.geoJson(data, {
                        onEachFeature: function (feature, layer) {
                            layer.bindPopup(feature.properties.info);
                        }
                    }).addTo(map);
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/ru/examples/markers.md
================================================
## Работа с маркерами

{toc}

### Описание

Ниже приведены примеры использования маркеров. Маркер можно добавить на карту с помощью метода
<code>addTo()</code>, но если вы планируете работать с группой марекров, мы рекомендуем использовать для этого
<code>FeatureGroup</code> (смотрите разделы "Обработка событий группы маркеров" и "Отображение нескольких
маркеров и подстройка границ"). Для получения подробной информации о маркерах перейдите в раздел документации
<a href="/doc/maps/ru/manual/markers">Маркеры</a>.

### Маркер с попапом

Маркер, при клике на который открывается попап с информацией:

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function () {
        var map = DG.map('map', {
            center: [54.98, 82.89],
            zoom: 15
        });

        DG.marker([54.98, 82.89]).addTo(map).bindPopup('Я попап!');
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Маркер с попапом</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 15
                    });

                    DG.marker([54.98, 82.89]).addTo(map).bindPopup('Я попап!');
                });
            </script>
        </body>
    </html>

### Перетаскиваемый маркер

Маркер, который пользователи могут перетаскивать:

Координаты маркера: <div id="location">54.981, 82.891</div>

<div id="map1" style="width: 100%; height: 400px;"></div>
<script type="text/javascript">
    var locationInfo = document.getElementById('location');
    DG.then(function () {
        var map,
            marker;

        map = DG.map('map1', {
            center: [54.981, 82.891],
            zoom: 15
        });

        marker = DG.marker([54.981, 82.891], {
            draggable: true
        }).addTo(map);

        marker.on('drag', function(e) {
            var lat = e.target._latlng.lat.toFixed(3),
                lng = e.target._latlng.lng.toFixed(3);

            locationInfo.innerHTML = lat + ', ' + lng;
        });
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Перетаскиваемый маркер</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            Координаты маркера: <div id="location">LatLng(54.98, 82.89)</div>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script type="text/javascript">
                var locationInfo = document.getElementById('location');

                DG.then(function () {
                    var map,
                        marker;

                    map = DG.map('map', {
                        center: [54.981, 82.891],
                        zoom: 15
                    });

                    marker = DG.marker([54.981, 82.891], {
                        draggable: true
                    }).addTo(map);

                    marker.on('drag', function(e) {
                        var lat = e.target._latlng.lat.toFixed(3),
                            lng = e.target._latlng.lng.toFixed(3);

                        locationInfo.innerHTML = lat + ', ' + lng;
                    });
                });
            </script>
        </body>
    </html>

### Маркер с пользовательской иконкой

Вы можете задать маркеру собственную иконку или простой элемент div вместо изображения:

<div id="map2" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            myIcon,
            myDivIcon;

        map = DG.map('map2', {
            center: [54.98, 82.89],
            zoom: 13
        });

        myIcon = DG.icon({
            iconUrl: 'https://maps.api.2gis.ru/2.0/example_logo.png',
            iconSize: [48, 48]
        });
        DG.marker([54.98, 82.89], {
            icon: myIcon
        }).addTo(map);

        myDivIcon = DG.divIcon({
            iconSize: [70, 20],
            html: '<b style="color:blue;">HTML-код</b>'
        });
        DG.marker([54.98, 82.87], {
            icon: myDivIcon
        }).addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Маркер с пользовательской иконкой</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        myIcon,
                        myDivIcon;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    myIcon = DG.icon({
                        iconUrl: 'https://maps.api.2gis.ru/2.0/example_logo.png',
                        iconSize: [48, 48]
                    });
                    DG.marker([54.98, 82.89], {
                        icon: myIcon
                    }).addTo(map);

                    myDivIcon = DG.divIcon({
                        iconSize: [70, 20],
                        html: '<b style="color:blue;">HTML-код</b>'
                    });
                    DG.marker([54.98, 82.87], {
                        icon: myDivIcon
                    }).addTo(map);
                });
            </script>
        </body>
    </html>

### Программное открытие маркера

Есть возможность открыть попап "по требованию". К примеру, по клику в ссылку или кнопку:

<button id='open-popup'>Открыть попап</button>
<div id="map3" style="width: 100%; height: 400px;"></div>
<script>
    var openPopupBtn = document.getElementById('open-popup');

    DG.then(function() {
        var map,
            marker;

        map = DG.map('map3', {
            center: [54.98, 82.89],
            zoom: 15
        });

        marker = DG.marker([54.98, 82.89]).addTo(map);
        marker.bindPopup('Я попап!');

        openPopupBtn.onclick = function() {
            marker.openPopup();
        }
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Программное открытие маркера</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <button id='open-popup'>Открыть попап</button>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                var openPopupBtn = document.getElementById('open-popup');

                DG.then(function() {
                    var map,
                        marker;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 15
                    });

                    marker = DG.marker([54.98, 82.89]).addTo(map);
                    marker.bindPopup('Я попап!');

                    openPopupBtn.onclick = function() {
                        marker.openPopup();
                    }
                });
            </script>
        </body>
    </html>

### Маркер с подсказкой

У маркера есть два вида подсказок, обычная и статическая. Оба варианта рассматриваются в следующем примере:

<div id="map4" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map4', {
            center: [54.98, 82.89],
            zoom: 15
        });

        DG.marker([54.98, 82.89])
            .addTo(map)
            .bindLabel('Я статическая подсказка!', {
                static: true
            });

        DG.marker([54.98, 82.88])
            .addTo(map)
            .bindLabel('Я обычная подсказка!');
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Маркер с подсказкой</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 15
                    });

                    DG.marker([54.98, 82.89])
                        .addTo(map)
                        .bindLabel('Я статическая подсказка!', {
                            static: true
                        });

                    DG.marker([54.98, 82.88])
                        .addTo(map)
                        .bindLabel('Я обычная подсказка!');
                });
            </script>
        </body>
    </html>

### Обработка событий группы маркеров

При клике в маркер, карта будет центрироваться по его позиции:

<div id="map5" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            marker1,
            marker2,
            marker3,
            group;

        map = DG.map('map5', {
            center: [54.98, 82.89],
            zoom: 13
        });

        marker1 = DG.marker([54.96, 82.889]).addTo(map);
        marker2 = DG.marker([54.98, 82.893]).addTo(map);
        marker3 = DG.marker([54.99, 82.896]).addTo(map);

        group = DG.featureGroup([marker1, marker2, marker3]);
        group.addTo(map);
        group.on('click', function(e) {
            map.setView([e.latlng.lat, e.latlng.lng]);
        });
    });
</script>


    <!DOCTYPE html>
    <html>
        <head>
            <title>Обработка событий группы маркеров</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        marker1,
                        marker2,
                        marker3,
                        group;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    marker1 = DG.marker([54.96, 82.889]).addTo(map);
                    marker2 = DG.marker([54.98, 82.893]).addTo(map);
                    marker3 = DG.marker([54.99, 82.896]).addTo(map);

                    group = DG.featureGroup([marker1, marker2, marker3]);
                    group.addTo(map);
                    group.on('click', function(e) {
                        map.setView([e.latlng.lat, e.latlng.lng]);
                    });
                });
            </script>
        </body>
    </html>

### Анимированное движение маркера

Пример маркера, который двигается по заданой траектории:
<div id="map6" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            marker;

        map = DG.map('map6', {
            center: [54.98, 82.89],
            zoom: 13
        });

        marker = DG.marker([54.98, 82.89]).addTo(map);

        var increment = 0.001;

        function move() {
            if (!map.getBounds().contains(marker.getLatLng())) {
                increment *= -1;
            }

            var newLat = marker.getLatLng().lat + increment,
                newLng = marker.getLatLng().lng + increment;

            marker.setLatLng([newLat, newLng]);
        }

        setInterval(move, 60);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Анимированное движение маркера</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        marker;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    marker = DG.marker([54.98, 82.89]).addTo(map);

                    var increment = 0.001;

                    function move() {
                        if (!map.getBounds().contains(marker.getLatLng())) {
                            increment *= -1;
                        }

                        var newLat = marker.getLatLng().lat + increment,
                            newLng = marker.getLatLng().lng + increment;

                        marker.setLatLng([newLat, newLng]);
                    }

                    setInterval(move, 60);
                });
            </script>
        </body>
    </html>

### Отображение нескольких маркеров и подстройка границ

Пример отображения и скрытия группы маркеров с автоматическим определением рамок карты:

<input id="show" type="button" value="Показать маркеры" /><input id="hide" type="button" value="Скрыть маркеры" />
<div id="map7" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            markers = DG.featureGroup(),
            coordinates = [];

        map = DG.map('map7', {
            center: [54.98, 82.89],
            zoom: 13
        });

        for (var i = 0; i < 100; i++) {
            coordinates[0] = 54.98 + Math.random();
            coordinates[1] = 82.89 + Math.random();
            DG.marker(coordinates).addTo(markers);
        }

        document.getElementById('hide').onclick = hideMarkers;
        document.getElementById('show').onclick = showMarkers;

        function showMarkers() {
            markers.addTo(map);
            map.fitBounds(markers.getBounds());
        };

        function hideMarkers() {
            markers.removeFrom(map);
        };
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Отображение/удаление нескольких маркеров, fitBounds</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <input id="hide" type="button" value="hide markers" />
            <input id="show" type="button" value="show markers" />
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
            DG.then(function() {
                var map,
                    markers = DG.featureGroup(),
                    coordinates = [];

                map = DG.map('map', {
                    center: [54.98, 82.89],
                    zoom: 13
                });

                for (var i = 0; i < 100; i++) {
                    coordinates[0] = 54.98 + Math.random();
                    coordinates[1] = 82.89 + Math.random();
                    DG.marker(coordinates).addTo(markers);
                }

                document.getElementById('hide').onclick = hideMarkers;
                document.getElementById('show').onclick = showMarkers;

                function showMarkers() {
                    markers.addTo(map);
                    map.fitBounds(markers.getBounds());
                };

                function hideMarkers() {
                    markers.removeFrom(map);
                };
            });
        </script>
        </body>
    </html>


================================================
FILE: src/doc/ru/examples/popups.md
================================================
## Работа с попапами

{toc}

### Описание

Ниже приведены примеры использования попапов. Для получения подробной информации перейдите в раздел документации
<a href="/doc/maps/ru/manual/popup">Попапы</a>.

### Открытие попапа при клике на маркер

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function () {
        var map = DG.map('map', {
            center: [54.98, 82.89],
            zoom: 15
        });

        DG.marker([54.98, 82.89]).addTo(map).bindPopup('Я попап!');
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Открытие попапа при клике на маркер</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 15
                    });

                    DG.marker([54.98, 82.89]).addTo(map).bindPopup('Я попап!');
                });
            </script>
        </body>
    </html>

### Открытие попапа по умолчанию и по требованию

<input id="showPopup" type="button" value="Открыть попап" />
<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    var showButton = document.getElementById('showPopup');

    DG.then(function() {
        var map,
            myPopUp;

        map = DG.map('map1', {
            center: [54.98, 82.89],
            zoom: 13
        });

        DG.popup([54.98, 82.89])
            .setLatLng([54.98, 82.89])
            .setContent('Я открыт по умолчанию')
            .openOn(map);

        myPopUp = DG.popup()
            .setLatLng([54.98, 82.89])
            .setContent('Я открылся по требованию и закрыл прошлый попап!');

        showButton.onclick = function() {myPopUp.openOn(map)};
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Открытие попапа по умолчанию и по требованию</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <input id="showPopup" type="button" value="Открыть попап" />
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                var showButton = document.getElementById('showPopup');

                DG.then(function() {
                    var map,
                        myPopUp;

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    DG.popup([54.98, 82.89])
                        .setLatLng([54.98, 82.89])
                        .setContent('Я открыт по умолчанию')
                        .openOn(map);

                    myPopUp = DG.popup()
                        .setLatLng([54.98, 82.89])
                        .setContent('Я открылся по требованию и закрыл прошлый попап!');

                    showButton.onclick = function() {myPopUp.openOn(map)};
                });
            </script>
        </body>
    </html>

### Добавление нескольких попапов на карту

<div id="map2" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            popups = DG.featureGroup(),
            coordinates = [];

        map = DG.map('map2', {
            center: [54.98, 82.89],
            zoom: 13
        });

        for (var i = 0; i < 10; i++) {
            coordinates[0] = 54.98 - Math.random();
            coordinates[1] = 82.89 + Math.random();
            DG.popup()
                .setLatLng(coordinates)
                .setContent('Я попап №' + i)
                .addTo(popups);
        }

        popups.addTo(map);
        map.fitBounds(popups.getBounds());
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Добавление нескольких попапов на карту</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        popups = DG.featureGroup(),
                        coordinates = [];

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    // создаем 10 попапов в случайных местах и добавляем их в группу
                    for (var i = 0; i < 10; i++) {
                        coordinates[0] = 54.98 - Math.random();
                        coordinates[1] = 82.89 + Math.random();
                        DG.popup()
                            .setLatLng(coordinates)
                            .setContent('Я попап №' + i)
                            .addTo(popups);
                    }

                    popups.addTo(map);

                    // фокусируем область видимости на попапах
                    map.fitBounds(popups.getBounds());
                });
            </script>
        </body>
    </html>

### Поведение попапа с параметром sprawling

<div id="map3" style="width: 300px; height: 150px;"></div>
<input style="width: 300px;" type="button" id="sprawling" value="Попап с включенным параметром sprawling"><br />
<input style="width: 300px;" type="button" id="no-sprawling" value="Попап без параметра sprawling"><br />
<input style="width: 300px;" type="button" id="minWidth" value="Попап с минимальной шириной 320px">
<script>
    DG.then(function () {
        var latLng = DG.latLng([54.98, 82.89]),
            map = DG.map('map3', {
                center: latLng,
                zoom: 13,
                fullscreenControl: false,
                zoomControl: false
            });

        document.getElementById('sprawling').onclick = function () {
            DG.popup({
                maxWidth: 350,
                sprawling: true
            })
            .setLatLng(latLng)
            .setContent('Я попап!')
            .openOn(map);
        };

        document.getElementById('no-sprawling').onclick = function () {
            DG.popup({
                maxWidth: 350
            })
            .setLatLng(latLng)
            .setContent('Я попап!')
            .openOn(map);
        };

        document.getElementById('minWidth').onclick = function () {
            DG.popup({
                maxWidth: 350,
                minWidth: 320
            })
            .setLatLng(latLng)
            .setContent('Я попап!')
            .openOn(map);
        };
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Поведение попапа с параметром sprawling</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 300px; height: 150px;"></div>
            <input style="width: 300px;" type="button" id="sprawling" value="Попап с включенным параметром sprawling"><br />
            <input style="width: 300px;" type="button" id="no-sprawling" value="Попап без параметра sprawling"><br />
            <input style="width: 300px;" type="button" id="minWidth" value="Попап с минимальной шириной 320px">
            <script>
                DG.then(function () {
                    var latLng = DG.latLng([54.98, 82.89]),
                        map;

                    // проинициализируем карту с шириной 300 пикселей
                    map = DG.map('map', {
                        center: latLng,
                        zoom: 13,
                        fullscreenControl: false,
                        zoomControl: false
                    });

                    // попап с включенным параметром sprawling
                    // растянется до границ карты
                    document.getElementById('sprawling').onclick = function () {
                        DG.popup({
                            maxWidth: 350,
                            sprawling: true
                        })
                        .setLatLng(latLng)
                        .setContent('Я попап!')
                        .openOn(map);
                    };

                    // попап без параметра sprawling
                    // подстроится под ширину контента
                    document.getElementById('no-sprawling').onclick = function () {
                        DG.popup({
                            maxWidth: 350
                        })
                        .setLatLng(latLng)
                        .setContent('Я попап!')
                        .openOn(map);
                    };

                    // попап с минимальной шириной 320px
                    // выйдет за границы карты
                    document.getElementById('minWidth').onclick = function () {
                        DG.popup({
                            maxWidth: 350,
                            minWidth: 320
                        })
                        .setLatLng(latLng)
                        .setContent('Я попап!')
                        .openOn(map);
                    };
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/ru/examples/vector-layers.md
================================================
## Работа с векторными слоями

{toc}

### Описание

Ниже приведены базовые примеры использования геометрических объектов. Для получения подробной информации о работе
с векторными слоями воспользуйтесь разделом документации <a href="/doc/maps/ru/manual/vector-layers">Векторные слои</a>.

### Отображение ломаной

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 500px;"></div>
<script>
    DG.then(function() {
        var map,
            coordinates,
            polyline;

        map = DG.map('map', {
            center: [55.036446, 82.897983],
            zoom: 11
        });

        coordinates = [[55.069288, 82.991367], [55.069288, 82.816615], [55.011648, 82.902103], [54.944714, 82.903152], [54.928935, 82.850967], [54.928541, 82.976280], [54.944517, 82.916541], [55.011704, 82.916885], [55.056508, 82.973514], [55.056508, 82.835498], [55.056705, 82.973857], [55.069288, 82.991367], [55.069288, 82.941928], [55.097193, 82.959094], [55.046282, 82.919956], [55.045692, 82.904163], [55.036446, 82.897983], [55.029756, 82.907596], [55.018932, 82.903819], [55.029362, 82.914119], [55.030543, 82.927165], [55.037823, 82.933345], [55.045101, 82.925105], [55.069681, 82.941928]];

        // создаем ломаную из массива географических точек
        polyline = DG.polyline(coordinates, {color: 'blue'}).addTo(map);

        // подстраиваем центр карты и масштаб так, чтобы ломаную было видно
        map.fitBounds(polyline.getBounds());
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Отображение ломаной</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 500px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        coordinates,
                        polyline;

                    map = DG.map('map', {
                        center: [55.036446, 82.897983],
                        zoom: 11
                    });

                    coordinates = [[55.069288, 82.991367], [55.069288, 82.816615], [55.011648, 82.902103], [54.944714, 82.903152], [54.928935, 82.850967], [54.928541, 82.976280], [54.944517, 82.916541], [55.011704, 82.916885], [55.056508, 82.973514], [55.056508, 82.835498], [55.056705, 82.973857], [55.069288, 82.991367], [55.069288, 82.941928], [55.097193, 82.959094], [55.046282, 82.919956], [55.045692, 82.904163], [55.036446, 82.897983], [55.029756, 82.907596], [55.018932, 82.903819], [55.029362, 82.914119], [55.030543, 82.927165], [55.037823, 82.933345], [55.045101, 82.925105], [55.069681, 82.941928]];

                    // создаем ломаную из массива географических точек
                    polyline = DG.polyline(coordinates, {
                        color: 'blue'
                    }).addTo(map);

                    // подстраиваем центр карты и масштаб, чтобы ломаную было видно
                    map.fitBounds(polyline.getBounds());
                });
            </script>
        </body>
    </html>

### Отображение прямоугольников

<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            coords1 = [[54.98, 82.87], [54.975, 82.91]],
            coords2 = [[54.985, 82.87], [54.982, 82.91]],
            coords3 = [[54.99, 82.87], [54.987, 82.91]],
            rectangles = DG.featureGroup();

        map = DG.map('map1', {
            center: [54.98, 82.89],
            zoom: 14
        });

        // Добавление прямоугольников в группу
        DG.rectangle(coords1, {color: "blue"}).addTo(rectangles);
        DG.rectangle(coords2, {color: "red"}).addTo(rectangles);
        DG.rectangle(coords3, {color: "green"}).addTo(rectangles);

        // Добавление группы на карту
        rectangles.addTo(map);

        // Подстройка границ карты
        map.fitBounds(rectangles.getBounds());
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Отображение прямоугольников</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        coords1 = [[54.98, 82.87], [54.975, 82.91]],
                        coords2 = [[54.985, 82.87], [54.982, 82.91]],
                        coords3 = [[54.99, 82.87], [54.987, 82.91]],
                        rectangles = DG.featureGroup();

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 14
                    });

                    // Добавление прямоугольников в группу
                    DG.rectangle(coords1, {color: "blue"}).addTo(rectangles);
                    DG.rectangle(coords2, {color: "red"}).addTo(rectangles);
                    DG.rectangle(coords3, {color: "green"}).addTo(rectangles);

                    // Добавление группы на карту
                    rectangles.addTo(map);

                    // Подстройка границ карты
                    map.fitBounds(rectangles.getBounds());
                });
            </script>
        </body>
    </html>

### Отображение многоугольников

<div id="map2" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            coords1 = [
                [54.98, 82.87],
                [54.975, 82.91],
                [54.974, 82.915],
                [54.971, 82.918],
                [54.970, 82.921]
            ],
            coords2 = [
                [54.985, 82.875],
                [54.98, 82.96],
                [54.979, 82.92],
                [54.976, 82.923]
            ],
            coords3 = [
                [54.99, 82.88],
                [54.985, 82.971],
                [54.984, 82.925],
                [54.981, 82.928],
                [54.980, 82.931]
            ],
            polygons = DG.featureGroup();

        map = DG.map('map2', {
            center: [54.98, 82.89],
            zoom: 13
        });

        DG.polygon(coords1, {color: "blue"}).addTo(polygons);
        DG.polygon(coords2, {color: "red"}).addTo(polygons);
        DG.polygon(coords3, {color: "green"}).addTo(polygons);

        polygons.addTo(map);
        map.fitBounds(polygons.getBounds());
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Отображение многоугольников</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        coords1 = [
                            [54.98, 82.87],
                            [54.975, 82.91],
                            [54.974, 82.915],
                            [54.971, 82.918],
                            [54.970, 82.921]
                        ],
                        coords2 = [
                            [54.985, 82.875],
                            [54.98, 82.96],
                            [54.979, 82.92],
                            [54.976, 82.923]
                        ],
                        coords3 = [
                            [54.99, 82.88],
                            [54.985, 82.971],
                            [54.984, 82.925],
                            [54.981, 82.928],
                            [54.980, 82.931]
                        ],
                        polygons = DG.featureGroup();

                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    // Добавление многоугольников в группу
                    DG.polygon(coords1, {color: "blue"}).addTo(polygons);
                    DG.polygon(coords2, {color: "red"}).addTo(polygons);
                    DG.polygon(coords3, {color: "green"}).addTo(polygons);

                    // Добавление группы на карту
                    polygons.addTo(map);

                    // Подстройка границ карты
                    map.fitBounds(polygons.getBounds());
                });
            </script>
        </body>
    </html>

### Отображение окружности и круглого маркера

<div id="map3" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map3', {
            center: [54.98, 82.89],
            zoom: 14
        });

        DG.circle([54.98, 82.89], 200, {color: 'red'}).addTo(map);
        DG.circleMarker([54.985, 82.89]).setRadius(100).addTo(map);
    })
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Отображение круга и круглого маркера</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 14
                    });

                    DG.circle([54.98, 82.89], 200, {color: 'red'}).addTo(map);
                    DG.circleMarker([54.985, 82.89]).setRadius(100).addTo(map);
                })
            </script>
        </body>
    </html>

### Векторные слои с подсказками и попапами

<div id="map4" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map4', {
            center: [54.98, 82.89],
            zoom: 14
        });

        DG.circle([54.98, 82.87], 200, {color: 'red'})
            .bindPopup('Я круг.')
            .bindLabel('нажми на круг')
            .addTo(map);

        DG.circleMarker([54.985, 82.89])
            .bindPopup('Я круглый маркер')
            .bindLabel('Нажми на круглый маркер')
            .setRadius(100)
            .addTo(map);

        DG.rectangle(
            [[54.98, 82.87], [54.975, 82.91]],
            {color: 'green'})
            .bindPopup('Я прямоугольник')
            .bindLabel('Нажми на прямоугольник')
            .addTo(map);

        DG.polygon(
            [[54.985, 82.875], [54.98, 82.96], [54.979, 82.92]],
            {color: 'yellow'})
            .bindPopup('Я многоугольник')
            .bindLabel('Нажми на многоугольник')
            .addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Векторные слои с подсказками и попапами</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 14
                    });

                    DG.circle([54.98, 82.87], 200, {color: 'red'})
                        .bindPopup('Я круг')
                        .bindLabel('Нажми на круг')
                        .addTo(map);

                    DG.circleMarker([54.985, 82.89])
                        .bindPopup('Я круглый маркер')
                        .bindLabel('Нажми на круглый маркер')
                        .setRadius(100)
                        .addTo(map);

                    DG.rectangle(
                        [[54.98, 82.87], [54.975, 82.91]],
                        {color: 'green'})
                        .bindPopup('Я прямоугольник')
                        .bindLabel('Нажми на прямоугольник')
                        .addTo(map);

                    DG.polygon(
                        [[54.985, 82.875], [54.98, 82.96], [54.979, 82.92]],
                        {color: 'yellow'})
                        .bindPopup('Я многоугольник')
                        .bindLabel('Нажми на многоугольник')
                        .addTo(map);
                });
            </script>
        </body>
    </html>

### Анимация отрисовки ломаной

<input id="playAnimation" type="button" value="Запустить анимацию" />
<div id="map5" style="width: 100%; height: 400px;"></div>
<script>
    var playAnimationButton = document.getElementById('playAnimation'); 

    DG.then(function() {
        var map = DG.map('map5', {
            center: [54.98, 82.94],
            zoom: 13
        });

        playAnimation.onclick = function() {
            var polyline = DG.polyline([]).addTo(map),
                counter = 0;

            (function draw() {
                polyline.addLatLng([54.98, 82.89 + counter / 10000]);

                if (++counter < 1000) {
                    window.setTimeout(draw, 10);
                } else {
                    counter = 0;
                    draw();
                };
            })();
        }
    })
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Анимация отрисовки ломаной</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <input id="playAnimation" type="button" value="Запустить анимацию" />
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                var playAnimationButton = document.getElementById('playAnimation'); 

                DG.then(function() {
                    var map = DG.map('map', {
                        center: [54.98, 82.94],
                        zoom: 13
                    });

                    playAnimation.onclick = function() {
                        var polyline = DG.polyline([]).addTo(map),
                            counter = 0;

                        (function draw() {
                            polyline.addLatLng([54.98, 82.89 + counter / 10000]);

                            if (++counter < 1000) {
                                window.setTimeout(draw, 10);
                            } else {
                                counter = 0;
                                draw();
                            };
                        })();
                    }
                })
            </script>
        </body>
    </html>


================================================
FILE: src/doc/ru/examples/wkt.md
================================================
## Работа с WKT

{toc}

### Описание

Ниже приведены примеры работы с WKT. Для получения подробной информации перейдите в раздел документации
<a href="/doc/maps/ru/manual/dg-wkt">WKT</a>.

### Отображение простых векторных слоев

<script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
<div id="map" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map,
            coord1 = 'POLYGON((82.91699 55.042136, 82.917522 55.040187, 82.918063 55.040235, 82.917540 55.042184,82.91699 55.042136))',
            coord2 = 'LINESTRING(82.91799 55.043136, 82.918522 55.041187, 82.919063 55.041235)',
            coord3 = 'POINT(82.914 55.042136)';

        map = DG.map('map', {
            center: [55.042136, 82.91699],
            zoom: 16
        });

        DG.Wkt.geoJsonLayer(coord1).addTo(map);

        DG.Wkt.geoJsonLayer(coord2).addTo(map);

        DG.Wkt.geoJsonLayer(coord3).addTo(map);
    })
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Отображение простых векторных слоев</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        coord1 = 'POLYGON((82.91699 55.042136, 82.917522 55.040187, 82.918063 55.040235, 82.917540 55.042184,82.91699 55.042136))',
                        coord2 = 'LINESTRING(82.91799 55.043136, 82.918522 55.041187, 82.919063 55.041235)',
                        coord3 = 'POINT(82.914 55.042136)';

                    map = DG.map('map', {
                        center: [55.042136, 82.91699],
                        zoom: 16
                    });

                    DG.Wkt.geoJsonLayer(coord1).addTo(map);

                    DG.Wkt.geoJsonLayer(coord2).addTo(map);

                    DG.Wkt.geoJsonLayer(coord3).addTo(map);
                })
            </script>
        </body>
    </html>

### Отображение составных векторных слоев

<div id="map1" style="width: 100%; height: 400px;"></div>
<script>
    DG.then(function() {
        var map = DG.map('map1', {
            center: [55.041836, 82.91699],
            zoom: 16
        });

        DG.Wkt.geoJsonLayer('MULTIPOLYGON(((82.91699 55.042136, 82.917522 55.040187, 82.918063 55.040235, 82.917540 55.042184,82.91699 55.042136)), ((82.91599 55.041136, 82.916522 55.039187, 82.917063 55.039235, 82.916540 55.041184,82.91599 55.041136)))').addTo(map);
        DG.Wkt.geoJsonLayer('MULTILINESTRING((82.91799 55.043136, 82.918522 55.041187, 82.919063 55.041235), (82.91899 55.044136, 82.919522 55.042187, 82.920063 55.042235))').addTo(map);
        DG.Wkt.geoJsonLayer('MULTIPOINT(82.914 55.042136, 82.915 55.043136, 82.915 55.042136, 82.914 55.043136)').addTo(map);
    });
</script>

    <!DOCTYPE html>
    <html>
        <head>
            <title>Отображение составных векторных слоев</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js"></script>
        </head>
        <body>
            <div id="map" style="width: 100%; height: 400px;"></div>
            <script>
                DG.then(function() {
                    var map,
                        coord1 = 'MULTIPOLYGON(((82.91699 55.042136, 82.917522 55.040187, 82.918063 55.040235, 82.917540 55.042184,82.91699 55.042136)), ((82.91599 55.041136, 82.916522 55.039187, 82.917063 55.039235, 82.916540 55.041184,82.91599 55.041136)))',
                        coord2 = 'MULTILINESTRING((82.91799 55.043136, 82.918522 55.041187, 82.919063 55.041235), (82.91899 55.044136, 82.919522 55.042187, 82.920063 55.042235))',
                        coord3 = 'MULTIPOINT(82.914 55.042136, 82.915 55.043136, 82.915 55.042136, 82.914 55.043136)';

                    map = DG.map('map', {
                        center: [55.041836, 82.91699],
                        zoom: 16
                    });

                    DG.Wkt.geoJsonLayer(coord1).addTo(map);

                    DG.Wkt.geoJsonLayer(coord2).addTo(map);

                    DG.Wkt.geoJsonLayer(coord3).addTo(map);
                });
            </script>
        </body>
    </html>


================================================
FILE: src/doc/ru/manual/base-classes.md
================================================
## Базовые классы

Служебные классы библотеки, необходимые для работы API карт и разработки
<a href="https://github.com/2gis/maps-api-2.0/blob/master/CONTRIBUTING.md#%D0%9A%D0%B0%D0%BA-%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%D1%82%D1%8C-%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8C" target="_blank">собственных модулей</a>.

{toc}

### DG.Class

<code>DG.Class</code> предоставляет возможность использовать ООП подход в разработке API карт, и используется
для реализации большинства классов, приведенных в этой документации.

Кроме реализации простой классической модели наследования, имеются несколько свойств для удобной организации кода,
такие как <code>options</code>, <code>includes</code> и <code>statics</code>.

    var MyClass = DG.Class.extend({
        initialize: function (greeter) {
            this.greeter = greeter;
            // конструктор класса
        },

        greet: function (name) {
            alert(this.greeter + ', ' + name)
        }
    });

    // создает объект класса MyClass и передает "Hello" в конструктор
    var a = new MyClass("Hello");

    // вызывает метод greet, который показывает всплывающее окно с текстом "Hello, World"
    a.greet("World");

#### Фабрики классов

Объекты в API карт можно создавать без использования ключевого слова <code>new</code>. Это достигается путем
дополнения описания каждого класса статическим методом, имеющим наименование класса, только в нижнем регистре.

    new DG.Map('map');
    DG.map('map');      // эквивалентный вызов

Вы можете использовать такой подход в своих классах, т.к. подобные методы реализованы достаточно просто:

    DG.map = function (id, options) {
        return new DG.Map(id, options);
    };

#### Наследование

Для определения новых классов используется <code>DG.Class.extend</code>, также метод <code>extend</code> можно использовать
в любом другом классе, который наследуется от <code>DG.Class</code>:

    var MyChildClass = MyClass.extend({
        // ... новые свойства и методы
    });

Данный код создаст класс, который унаследует все методы и свойства родительского класса (через цепочку прототипов),
при необходимости добавляя или переопределяя родительские методы и свойства. Кроме того, корректно обрабатывается
оператор <code>instanceof</code>:

    var a = new MyChildClass();
    a instanceof MyChildClass; // true
    a instanceof MyClass; // true

Вы можете вызывать родительские методы (включая конструктор) из дочерних классов (так, как вы бы делали это с помощью
вызова <code>super</code> в других языках программирования) с помощью JavaScript функций <code>call</code> или <code>apply</code>:

    var MyChildClass = MyClass.extend({
        initialize: function () {
            MyClass.prototype.initialize.call(this, "Yo");
        },

        greet: function (name) {
            MyClass.prototype.greet.call(this, 'bro ' + name + '!');
        }
    });

    var a = new MyChildClass();
    a.greet('Jason'); // выведет "Yo, bro Jason!"

#### Объект опций

<code>options</code> &mdash; ссылка на специальный объект, свойства которого, в отличии от других объектов
передаваемых через <code>extend</code>, будут объединены со свойствами аналогичного объекта родителя, вместо
полного переопределения объекта. Это позволяет управлять конфигурацией объектов и значениями по умолчанию:

    var MyClass = DG.Class.extend({
        options: {
            myOption1: 'foo',
            myOption2: 'bar'
        }
    });

    var MyChildClass = DG.Class.extend({
        options: {
            myOption1: 'baz',
            myOption3: 5
        }
    });

    var a = new MyChildClass();
    a.options.myOption1; // 'baz'
    a.options.myOption2; // 'bar'
    a.options.myOption3; // 5

Также существует метод <a href="/doc/maps/ru/manual/utils#util-setoptions"><code>DG.Util.setOptions</code></a>,
который позволяет объединять опции, переданные в конструктор, с опциями, заданными по умолчанию:

    var MyClass = DG.Class.extend({
        options: {
            foo: 'bar',
            bla: 5
        },

        initialize: function (options) {
            DG.Util.setOptions(this, options);
            ...
        }
    });

    var a = new MyClass({bla: 10});
    a.options; // {foo: 'bar', bla: 10}

#### Поддержка создания миксинов

<code>includes</code> &mdash; ссылка на специальный объект, свойства и методы которого будут объединены со свойствами
и методами экземпляров класса (такие объекты называются mixin-ами).

     var MyMixin = {
        foo: function () { ... },
        bar: 5
    };

    var MyClass = DG.Class.extend({
        includes: MyMixin
    });

    var a = new MyClass();
    a.foo();

Также, вы можете подмешивать объекты в процессе выполнения программы, с помощью метода <code>include</code>:

    MyClass.include(MyMixin);

#### Поддержка статических членов класса

<code>statics</code> &mdash; ссылка на специальный объект, свойства и методы которого будут объединены со статическими
свойствами и методами класса. Бывает удобно использовать для определения констант:

    var MyClass = DG.Class.extend({
        statics: {
            FOO: 'bar',
            BLA: 5
        }
    });

    MyClass.FOO; // 'bar'

#### Перехватчики конструктора

Если вы разрабатываете модуль к API карт, существует вероятность того, что вам понадобится выполнить
дополнительные действия при инициализации объектов существующих классов (например, при инициализации
объекта <a href="/doc/maps/ru/manual/geometries#polyline"><code>DG.Polyline</code></a>).

Для подобного рода задач есть метод <code>addInitHook</code>:

    MyClass.addInitHook(function () {
        // ... выполнить дополнительные действия при вызове конструктора
        // например, добавить обработчики событий, установить значения свойств и т.п.
    });

Также можно использовать сокращенную запись, если вам надо сделать всего лишь один дополнительный вызов метода:

    MyClass.addInitHook('methodName', arg1, arg2, …);

#### Функции

<table>
    <thead>
        <tr>
            <th>Функция</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="class-extend">
            <td><code><b>extend</b>(
                <nobr>&lt;Object&gt; <i>props</i> )</nobr>
            </code></td>

            <td><code>Function</code></td>
            <td>Возвращает функцию Javascript, являющуюся конструктором класса (в дальнейшем, функция должна вызываться с
                <code>new</code>), который <a href="#наследование">наследует</a> методы и свойства базового класса.</td>
        </tr>
        <tr id="class-include">
            <td><code><b>include</b>(
                <nobr>&lt;Object&gt; <i>properties</i> )</nobr>
            </code></td>

            <td><code></code></td>
            <td>Подмешивает методы и свойства объекта в текущий класс.</td>
        </tr>
        <tr id="class-mergeoptions">
            <td><code><b>mergeOptions</b>(
                <nobr>&lt;Object&gt; <i>options</i> )</nobr>
            </code></td>

            <td><code></code></td>
            <td>Объединяет объект опций с объектом опций класса по умолчанию.</td>
        </tr>
        <tr id="class-addinithook">
            <td><code><b>addInitHook</b>(
                <nobr>&lt;Function&gt; <i>fn</i> )</nobr>
            </code></td>

            <td><code></code></td>
            <td>Добавляет функцию-перехватчик конструктора к классу.</td>
        </tr>
    </tbody>
</table>

### DG.Evented

Классы, использующие событийную модель (такие как <a href="/doc/maps/ru/manual/map#dgmap"><code>Map</code></a>
и <a href="/doc/maps/ru/manual/markers#dgmarker"><code>Marker</code></a>), наследуют методы <code>DG.Evented</code>.
В общем случае, класс дает возможность инициировать выполнение последовательности функций, при возникновении
какого-либо события, связанного с объектом (например, пользователь щелкнул мышью по карте, тем самым создав
событие <code>&#39;click&#39;</code>).

    map.on('click', function(e) {
        alert(e.latlng);
    } );

Для того, чтобы можно было добавить и впоследствии удалить обработчик события, опишите обработчик
с помощью внешней функции, ссылку на которую потом можно будет передать в методы данного класса:

    function onClick(e) { ... }
    map.on('click', onClick);
    map.off('click', onClick);

#### Методы

<table id="dgevented-methods">
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="evented-on">
            <td><code><b>on</b>(
                <nobr>&lt;String&gt; <i>type</i></nobr>,
                <nobr>&lt;Function&gt; <i>fn</i></nobr>,
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет обработчик (<code>fn</code>) для определенного типа событий. Вы также можете указать
                контекст вызова обработчика (объект, на который ссылается ключевое слово <code>this</code>
                внутри обработчика). Также, можно указать несколько типов событий, разделив их пробелами
                (например: <code>&#39;click dblclick&#39;</code>).</td>
        </tr>
        <tr>
            <td><code><b>on</b>(
                <nobr>&lt;Object&gt; <i>eventMap</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет набор пар &#39;тип/обработчик&#39; в качестве обработчиков событий
                (например: <code>{click: onClick, mousemove: onMouseMove}</code>).</td>
        </tr>
        <tr id="evented-off">
            <td><code><b>off</b>(
                <nobr>&lt;String&gt; <i>type</i></nobr>,
                <nobr>&lt;Function&gt; <i>fn?</i></nobr>,
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Удаляет ранее добавленную функцию обработчика событий. Если функция не указана, то у объекта будут удалены
                все обработчики для данного типа событий. Замечание: если методу <code>on</code> передавался
                контекст, этот же контекст должен быть передан и методу <code>off</code>, для того чтобы обработчик был удален.</td>
        </tr>
        <tr>
            <td><code><b>off</b>(
                <nobr>&lt;Object&gt; <i>eventMap</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Удаляет набор пар &#39;тип/обработчик&#39; обработчиков событий.</td>
        </tr>
        <tr>
            <td><code><b>off</b>()</code></td>

            <td><code>this</code></td>
            <td>Удаляет все обработчики для всех типов событий.</td>
        </tr>
        <tr id="evented-fire">
            <td><code><b>fire</b>(
                <nobr>&lt;String&gt; <i>type</i></nobr>,
                <nobr>&lt;Object&gt; <i>data?</i></nobr>,
                <nobr>&lt;Boolean&gt; <i>propagate?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Инициирует событие определенного типа. Опционально можно передать объект с данными события,
                который будет передан первым параметром в функцию-обработчик. Также возможно указать,
                чтобы событие распространилось на родительские объекты.</td>
        </tr>
        <tr id="evented-listens">
            <td><code><b>listens</b>(
                <nobr>&lt;String&gt; <i>type</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если существуют хотя бы один обработчик для заданного типа событий.</td>
        </tr>
        <tr id="evented-once">
            <td><code><b>once</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Метод эквивалентен <a href="#evented-on"><code>on(…)</code></a>, но обработчик события будет вызван
                один раз, после чего удален.</td>
        </tr>
        <tr id="evented-addeventparent">
            <td><code><b>addEventParent</b>(
                <nobr>&lt;<a href="#dgevented">Evented</a>&gt; <i>obj</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет объект <a href="#dgevented"><code>Evented</code></a> в качестве получателя событий от
                текущего объекта.</td>
        </tr>
        <tr id="evented-removeeventparent">
            <td><code><b>removeEventParent</b>(
                <nobr>&lt;<a href="#dgevented">Evented</a>&gt; <i>obj</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Удаляет объект, ранее добавленный методом <a href="#evented-addeventparent"><code>addEventParent</code></a>.</td>
        </tr>
        <tr id="evented-addeventlistener">
            <td><code><b>addEventListener</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Псевдоним для <a href="#evented-on"><code>on(…)</code></a></td>
        </tr>
        <tr id="evented-removeeventlistener">
            <td><code><b>removeEventListener</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Псевдоним для <a href="#evented-off"><code>off(…)</code></a></td>
        </tr>
        <tr id="evented-clearalleventlisteners">
            <td><code><b>clearAllEventListeners</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Псевдоним для <a href="#evented-off"><code>off()</code></a></td>
        </tr>
        <tr id="evented-addonetimeeventlistener">
            <td><code><b>addOneTimeEventListener</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Псевдоним для <a href="#evented-once"><code>once(…)</code></a></td>
        </tr>
        <tr id="evented-fireevent">
            <td><code><b>fireEvent</b>(<i>…</i>)</code></td>

            <td><code>this</code></td>
            <td>Псевдоним для <a href="#evented-fire"><code>fire(…)</code></a></td>
        </tr>
        <tr id="evented-haseventlisteners">
            <td><code><b>hasEventListeners</b>(<i>…</i>)</code></td>

            <td><code>Boolean</code></td>
            <td>Псевдоним для <a href="#evented-listens"><code>listens(…)</code></a></td>
        </tr>
    </tbody>
</table>

### DG.Layer

Все объекты слоев API карт, так или иначе, задействуют методы базового класса <code>DG.Layer</code>.
Класс наследует все методы, свойства и событийную модель от <a href="#dgevented"><code>DG.Evented</code></a>.

    var layer = DG.Marker(latlng).addTo(map);
    layer.addTo(map);
    layer.remove();

#### Опции

<table id="dglayer-options">
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layer-pane">
            <td><code><b>pane</b></code></td>
            <td><code>String</code></td>
            <td><code>&#x27;overlayPane&#x27;</code></td>
            <td>По умолчанию, слои добавляются в т.н. <a href="/doc/maps/ru/manual/map#map-overlaypane">панель слоев</a>.
                Поведение по умолчанию можно изменить, переопределив данную опцию.</td>
        </tr>
    </tbody>
</table>

#### События

<table id="dglayer-events">
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="layer-add">
            <td><code><b>add</b></code></td>
            <td><code><a href="#объекты-событий">Event</a></code></td>
            <td>Возникает после того, как слой будет добавлен к карте.</td>
        </tr>
        <tr id="layer-remove">
            <td><code><b>remove</b></code></td>
            <td><code><a href="#объекты-событий">Event</a></code></td>
            <td>Возникает после того, как слой будет удален с карты.</td>
        </tr>
    </tbody>
</table>

##### События попапов

<table id="dglayer-popup-events">
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layer-popupopen">
            <td><code><b>popupopen</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Возникает при открытии попапа, прикрепленного к данному слою.</td>
        </tr>
        <tr id="layer-popupclose">
            <td><code><b>popupclose</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Возникает при закрытии попапа, привязанного к данному слою.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table id="dglayer-methods">
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layer-addto">
            <td><code><b>addTo</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/map#dgmap">Map</a>&gt; <i>map</i>)</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет слой на карту.</td>
        </tr>
        <tr id="layer-remove">
            <td><code><b>remove</b>()</code></td>

            <td><code>this</code></td>
            <td>Удаляет слой с карты, к которой он в данный момент прикреплен.</td>
        </tr>
        <tr id="layer-removefrom">
            <td><code><b>removeFrom</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Удаляет слой с карты.</td>
        </tr>
        <tr id="layer-getpane">
            <td><code><b>getPane</b>(
                <nobr>&lt;String&gt; <i>name?</i> )</nobr>
            </code></td>

            <td><code>HTMLElement</code></td>
            <td>Возвращает <code>HTMLElement</code>, представляющий панель на карте с данным именем.
                Если аргумент <code>name</code> не задан, возвращает панель, в которой находится данный слой.</td>
        </tr>
    </tbody>
</table>

##### Методы попапов

Все слои поддерживают набор методов, удобных для связывания с ними попапов.

    var layer = DG.Polygon(latlngs).bindPopup('Hi There!').addTo(map);
    layer.openPopup();
    layer.closePopup();

Попапы автоматически открываются при щелчке мышью по слою, а также закрываются,
при удалении слоя или открытии другого попапа.

<table id="dglayer-popup-methods">
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layer-bindpopup">
            <td><code><b>bindPopup</b>(
                <nobr>&lt;String|HTMLElement|Function|Popup&gt; <i>content</i>,</nobr>
                <nobr>&lt;<a href="/doc/maps/ru/manual/popup#popup-option">Popup options</a>&gt; <i>options?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Связывает попап со слоем и устанавливает необходимые обработчики событий.
                Если в качестве параметра передать функцию, она получит текущий объект в качестве своего
                первого аргумента и должна вернуть <code>String</code> или <code>HTMLElement</code>.</td>
        </tr>
        <tr id="layer-unbindpopup">
            <td><code><b>unbindPopup</b>()</code></td>

            <td><code>this</code></td>
            <td>Удаляет попап, ранее привязанный с помощью <code>bindPopup</code>.</td>
        </tr>
        <tr id="layer-openpopup">
            <td><code><b>openPopup</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Открывает, связанный со слоем попап, в заданных координатах
                <a href="/doc/maps/ru/manual/basic-types#dglatlng"><code>latlng</code></a>
                или в координатах, сохраненных в параметрах самого элемента.</td>
        </tr>
        <tr id="layer-closepopup">
            <td><code><b>closePopup</b>()</code></td>

            <td><code>this</code></td>
            <td>Закрывает, связанный со слоем попап, если он ранее был открыт. Также, может работать
                как триггер, открывая или закрывая связанный элемент, в зависимости от его предыдущего состояния.
                Возвращает <code>true</code>, если попап, был открыт в момент вызова метода.</td>
        </tr>
        <tr id="layer-setpopupcontent">
            <td><code><b>setPopupContent</b>(
            <nobr>&lt;String|HTMLElement|Popup&gt; <i>content</i>,</nobr>
                <nobr>&lt;<a href="/doc/maps/ru/manual/popup#popup-option">Popup options</a>&gt; <i>options?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Задает содержимое попапа, связанного с данным слоем.</td>
        </tr>
        <tr id="layer-getpopup">
            <td><code><b>getPopup</b>()</code></td>

            <td><code><a href="/doc/maps/ru/manual/popup#dgpopup">Popup</a></code></td>
            <td>Возвращает попап, связанный с данным слоем.</td>
        </tr>
    </tbody>
</table>

##### Методы расширения

Каждый слой, который наследуется от <a href="#dglayer"><code>DG.Layer</code></a>, должен реализовать следующие методы.

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layer-onadd">
            <td><code><b>onAdd</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Должен содержать код, который создает DOM элемент для слоя и добавляет его в одну из панелей карты,
                а также создает обработчики для соответствующих событий карты. Вызывается из
                <a href="/doc/maps/ru/manual/map#map-addlayer"><code>map.addLayer(layer)</code></a>.</td>
        </tr>
        <tr id="layer-onremove">
            <td><code><b>onRemove</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Должен содержать код, который убирает слой и сопутствующие элементы из DOM, а также удаляет обработчики,
                ранее выставленные в <a href="#layer-onadd"><code>onAdd</code></a>. Вызывается из
                <a href="/doc/maps/ru/manual/map#map-removelayer"><code>map.removeLayer(layer)</code></a>.</td>
        </tr>
        <tr id="layer-getevents">
            <td><code><b>getEvents</b>()</code></td>

            <td><code>Object</code></td>
            <td>Опциональный метод, который должен возвращать объект вида <code>{ viewreset: this._reset }</code>,
                подходящего для вызова <a href="#evented-addeventlistener"><code>addEventListener</code></a>.
                Эти обработчики будут автоматически добавлены и удалены для событий карты вместе с операциями добавления
                и удаления слоя.</td>
        </tr>
        <tr id="layer-beforeadd">
            <td><code><b>beforeAdd</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Опциональный метод, который вызывается из <a href="/doc/maps/ru/manual/map#map-addlayer"><code>map.addLayer(layer)</code></a>,
                перед тем как слой будет добавлен к карте и инициализированы соответствующие обработчики событий.
                Объект карты может быть не до конца подготовлен к использованию (не загружены необходимые данные и т.п.)
                в момент вызова. Поэтому метод можно использовать только для базовой инициализации структур данных слоя.</td>
        </tr>
    </tbody>
</table>

События, унаследованные от <a href="#dgevented">Evented</a> <!-- TODO: include events -->

### DG.Control

Базовый класс, от которого наследуют все элементы управления. Обеспечивает позиционирование элементов управления.

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-position">
            <td><code><b>position</b></code></td>
            <td><code>String</code></code></td>
            <td><code>&#x27;topright&#x27;</code></td>
            <td>Местоположение элемента управления (один из углов карты). Возможные значения: <code>&#39;topleft&#39;</code>,
                <code>&#39;topright&#39;</code>, <code>&#39;bottomleft&#39;</code> или <code>&#39;bottomright&#39;</code></td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-getposition">
            <td><code><b>getPosition</b>()</code></td>

            <td><code>string</code></td>
            <td>Возвращает позицию элемента управления.</td>
        </tr>
        <tr id="control-setposition">
            <td><code><b>setPosition</b>(
                <nobr>&lt;string&gt; <i>position</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Задает позицию элемента управления.</td>
        </tr>
        <tr id="control-getcontainer">
            <td><code><b>getContainer</b>()</code></td>

            <td><code>HTMLElement</code></td>
            <td>Возвращает объект HTMLElement, который содержит элемент управления.</td>
        </tr>
        <tr id="control-addto">
            <td><code><b>addTo</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет элемент управления на карту.</td>
        </tr>
        <tr id="control-remove">
            <td><code><b>remove</b>()</code></td>

            <td><code>this</code></td>
            <td>Удаляет элемент управления с карты, на которой он сейчас активен.</td>
        </tr>
    </tbody>
</table>

### DG.Handler

Базовый класс для обработчиков взаимодействия с картой.

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="handler-enable">
            <td><code><b>enable</b>()</code></td>

            <td><code></code></td>
            <td>Включает обработчик</td>
        </tr>
        <tr id="handler-disable">
            <td><code><b>disable</b>()</code></td>

            <td><code></code></td>
            <td>Отключает обработчик</td>
        </tr>
        <tr id="handler-enabled">
            <td><code><b>enabled</b>()</code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если обработчик активен</td>
        </tr>
    </tbody>
</table>

#### Методы расширения функционала

Классы, наследующие от <a href="#dghandler"><code>Handler</code></a>, должны реализовывать следующие методы:

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="handler-addhooks">
            <td><code><b>addHooks</b>()</code></td>

            <td><code></code></td>
            <td>Вызывается при включении обработчика, должен добавлять обработчики событий.</td>
        </tr>
        <tr id="handler-removehooks">
            <td><code><b>removeHooks</b>()</code></td>

            <td><code></code></td>
            <td>Вызывается при отключении обработчика, должен удалять обработчики событий.</td>
        </tr>
    </tbody>
</table>

### DG.Projection

Объект для работы с <a href="http://en.wikipedia.org/wiki/Map_projection">картографической проекцией</a>.
Содержит методы для перевода географических координат в координаты на плоскости и обратно.

API карт использует сферическую проекцию Меркатора (EPSG:3857).

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="projection-project">
            <td><code><b>project</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Осуществляет проекцию географических координат на двухмерную координатную плоскость.</td>
        </tr>
        <tr id="projection-unproject">
            <td><code><b>unproject</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Обратная операция от <code>project</code>. Осуществляет проекцию двухмерных координат в плоскости
                на географические координаты.</td>
        </tr>
    </tbody>
</table>

#### Свойства

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="projection-bounds">
            <td><code><b>bounds</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#latlngbounds">LatLngBounds</a></code></td>
            <td>Географические границы области, в пределах которой возможно осуществление преобразований.</td>
        </tr>
    </tbody>
</table>

### DG.Renderer

Базовый класс, использующийся для реализации движков отображения векторных объектов (<code>DG.SVG</code>,
<code>DG.Canvas</code>). В общем случае, используется для отображения геометрических объектов.

Обслуживает операции, связанные с DOM-контейнером, его размерами и анимацией процесса
масштабирования. <a href="#dgrenderer"><code>Renderer</code></a> выступает в качестве неявной группы слоев для
всех элементов, которые наследуются от <a href="/doc/maps/ru/manual/vector-layers#dgpath"><code>DG.Path</code></a>.
Все векторные элементы используют движок отображения, который может быть задан неявно (и тогда API карт примет решение
о том, какой тип движка использовать для отображения) или явно (с помощью опции векторного слоя
<a href="/doc/maps/ru/manual/vector-layers#path-renderer"><code>renderer</code></a>). Не используйте этот класс
напрямую. Используйте классы, которые наследуются от него, такие как <code>DG.SVG</code> или <code>DG.Canvas</code>.

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>Значение по умолчанию</th>
            <th>Описание</th>
        </tr>
        </thead><tbody>
        <tr id="renderer-padding">
            <td><code><b>padding</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.1</code></td>
            <td>Насколько расширять границы отсечения выводимых объектов относительно границ окна, в котором отображается карта.
                Измеряется в относительных единицах, где 0.1 соответствует 10% размера окна в каждом из направлений.</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="#dglayer">Layer</a> <!-- TODO: include options -->

#### Events

События, унаследованные от <a href="#dglayer">Layer</a> <!-- TODO: include events -->

#### Methods

Методы, унаследованные от <a href="#dglayer">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="#dgevented">Evented</a> <!-- TODO: include methods -->

### Объекты событий

Когда класс, унаследованный от <a href="#dgevented"><code>Evented</code></a>, инициирует событие,
вызывается функция-обработчик с аргументом, представляющим собой объект с данными о событии, например:

    map.on('click', function(ev) {
        alert(ev.latlng); // ev объект с данными о событии (MouseEvent, в данном случае)
    });

Информация, которая попадает в функцию обработчик, зависит от типа события:

#### Event

Базовый объект события и другие объекты событий содержат следующие свойства:

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="event-type">
            <td><code><b>type</b></code></td>
            <td><code>String</code></td>
            <td>Тип события (например, <code>&#39;click&#39;</code>).</td>
        </tr>
        <tr id="event-target">
            <td><code><b>target</b></code></td>
            <td><code>Object</code></td>
            <td>Объект, который инициировал событие.</td>
        </tr>
    </tbody>
</table>

#### MouseEvent

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="mouseevent-latlng">
            <td><code><b>latlng</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#latlng">LatLng</a></code></td>
            <td>Географические координаты точки, в которой было инициировано событие мыши.</td>
        </tr>
        <tr id="mouseevent-layerpoint">
            <td><code><b>layerPoint</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Пиксельные координаты, в которых было инициировано событие мыши, относительно слоя карты.</td>
        </tr>
        <tr id="mouseevent-containerpoint">
            <td><code><b>containerPoint</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Пиксельные координаты, в которых было инициировано событие мыши, относительно объекта-контейнера карты.</td>
        </tr>
        <tr id="mouseevent-originalevent">
            <td><code><b>originalEvent</b></code></td>
            <td><code>DOMMouseEvent</code></td>
            <td>Данные оригинального события мыши, инициированного браузером.</td>
        </tr>
    </tbody>
</table>

Свойства, унаследованные от <a href="#event">Event</a> <!-- TODO: include properties -->

#### LocationEvent

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="locationevent-latlng">
            <td><code><b>latlng</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#latlng">LatLng</a></code></td>
            <td>Географическое положение пользователя</td>
        </tr>
        <tr id="locationevent-bounds">
            <td><code><b>bounds</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#latlngbounds">LatLngBounds</a></code></td>
            <td>Географические границы, в которых находится пользователь (с учетом точности определения местоположения).</td>
        </tr>
        <tr id="locationevent-accuracy">
            <td><code><b>accuracy</b></code></td>
            <td><code>Number</code></td>
            <td>Точность определения местоположения в метрах.</td>
        </tr>
        <tr id="locationevent-altitude">
            <td><code><b>altitude</b></code></td>
            <td><code>Number</code></td>
            <td>Высота над поверхностью земли в метрах, согласно координатной системе WGS84.</td>
        </tr>
        <tr id="locationevent-altitudeaccuracy">
            <td><code><b>altitudeAccuracy</b></code></td>
            <td><code>Number</code></td>
            <td>Точность определения высоты в метрах.</td>
        </tr>
        <tr id="locationevent-heading">
            <td><code><b>heading</b></code></td>
            <td><code>Number</code></td>
            <td>Направление движения в градусах, считается с севера, в направлении по часовой стрелке.</td>
        </tr>
        <tr id="locationevent-speed">
            <td><code><b>speed</b></code></td>
            <td><code>Number</code></td>
            <td>Скорость в метрах в секунду.</td>
        </tr>
        <tr id="locationevent-timestamp">
            <td><code><b>timestamp</b></code></td>
            <td><code>Number</code></td>
            <td>Момент времени измерения местоположения.</td>
        </tr>
    </tbody>
</table>

Свойства, унаследованные от <a href="#event">Event</a> <!-- TODO: include properties -->

#### ErrorEvent

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="errorevent-message">
            <td><code><b>message</b></code></td>
            <td><code>String</code></td>
            <td>Сообщение об ошибке.</td>
        </tr>
        <tr id="errorevent-code">
            <td><code><b>code</b></code></td>
            <td><code>Number</code></td>
            <td>Код ошибки (если имеется).</td>
        </tr>
    </tbody>
</table>

Свойства, унаследованные от <a href="#event">Event</a> <!-- TODO: include properties -->

#### LayerEvent

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layerevent-layer">
            <td><code><b>layer</b></code></td>
            <td><code><a href="#dglayer">Layer</a></code></td>
            <td>Слой, который был добавлен или удален.</td>
        </tr>
    </tbody>
</table>

Свойства, унаследованные от <a href="#event">Event</a> <!-- TODO: include properties -->

#### LayersControlEvent

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layerscontrolevent-layer">
            <td><code><b>layer</b></code></td>
            <td><code><a href="#dglayer">Layer</a></code></td>
            <td>Слой, который был добавлен или удален.</td>
        </tr>
        <tr id="layerscontrolevent-name">
            <td><code><b>name</b></code></td>
            <td><code>String</code></td>
            <td>Наименовани слоя, который был добавлен или удален.</td>
        </tr>
    </tbody>
</table>

Свойства, унаследованные от <a href="#event">Event</a> <!-- TODO: include properties -->

#### TileEvent

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
	</thead>
	<tbody>
        <tr id="tileevent-tile">
            <td><code><b>tile</b></code></td>
            <td><code>HTMLElement</code></td>
            <td>Элемент тайла (изображение).</td>
        </tr>
    </tbody>
</table>

Свойства, унаследованные от <a href="#event">Event</a> <!-- TODO: include properties -->

#### TileErrorEvent

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="tileerrorevent-tile">
            <td><code><b>tile</b></code></td>
            <td><code>HTMLElement</code></td>
            <td>Элемент тайла (изображение).</td>
        </tr>
    </tbody>
</table>

Свойства, унаследованные от <a href="#event">Event</a> <!-- TODO: include properties -->

#### ResizeEvent

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="resizeevent-oldsize">
            <td><code><b>oldSize</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Старый размер, до изменения размера.</td>
        </tr>
        <tr id="resizeevent-newsize">
            <td><code><b>newSize</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Новый размер, после изменения размера.</td>
        </tr>
    </tbody>
</table>

Свойства, унаследованные от <a href="#event">Event</a> <!-- TODO: include properties -->

#### GeoJSON event

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
        </thead><tbody>
        <tr id="geojson-event-layer">
            <td><code><b>layer</b></code></td>
            <td><code><a href="#dglayer">Layer</a></code></td>
            <td>Слой GeoJSON объекта, добавленного на карту.</td>
        </tr>
        <tr id="geojson-event-properties">
            <td><code><b>properties</b></code></td>
            <td><code>Object</code></td>
            <td>Опции GeoJSON объекта.</td>
        </tr>
        <tr id="geojson-event-geometrytype">
            <td><code><b>geometryType</b></code></td>
            <td><code>String</code></td>
            <td>Тип геометрии GeoJSON объекта.</td>
        </tr>
        <tr id="geojson-event-id">
            <td><code><b>id</b></code></td>
            <td><code>String</code></td>
            <td>GeoJSON ID объекта (если задан).</td>
        </tr>
    </tbody>
</table>

Свойства, унаследованные от <a href="#event">Event</a> <!-- TODO: include properties -->

#### Popup event

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
        </thead><tbody>
        <tr id="popup-event-popup">
            <td><code><b>popup</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/popup#dgpopup">Popup</a></code></td>
            <td>Попап, который был открыт или закрыт.</td>
        </tr>
    </tbody>
</table>

Свойства, унаследованные от <a href="#event">Event</a> <!-- TODO: include properties -->

#### DragEndEvent

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="dragendevent-distance">
            <td><code><b>distance</b></code></td>
            <td><code>Number</code></td>
            <td>Расстояние в пикселях на которое был сдвинут элемент.</td>
        </tr>
    </tbody>
</table>

#### MetaEvent

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>latlng</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Географические координаты точки объекта допслоя.</td>
        </tr>
        <tr>
            <td><code><b>meta</b></code></td>
            <td><code>Object</code></td>
            <td>Метаданные объекта допслоя.</td>
        </tr>
    </tbody>
</table>

#### LangEvent

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>lang</b></code></td>
            <td><code>String</code></td>
            <td>Текущий язык карты.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/basic-types.md
================================================
## Базовые типы данных

В данном разделе описаны классы базовых типов данных, которые часто встречаются на страницах руководства API карт
и которые необходимы для работы с многими объектами карты.

{toc}

### DG.LatLng

Географическая точка с определенной широтой и долготой.

    var latlng = DG.latLng(54.98, 82.89);

Все методы, которые принимают объекты LatLng, также принимают широту и долготу в виде простого массива или объекта
(если не указано иное), то есть данные записи эквивалентны:

    map.panTo([54.98, 82.89]);
    map.panTo({lon: 82.89, lat: 54.98});
    map.panTo({lat: 54.98, lng: 82.89});
    map.panTo(DG.latLng(54.98, 82.89));

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="latlng-l-latlng">
            <td><code><b>DG.latLng</b>(
                <nobr>&lt;Number&gt; <i>latitude</i>,</nobr>
                <nobr>&lt;Number&gt; <i>longitude</i>,</nobr>
                <nobr>&lt;Number&gt; <i>altitude?</i> )</nobr>
            </code></td>
            <td>Создает объект, представляющий географическую точку с определенной широтой и долготой
                (и опционально высотой).</td>
        </tr>
        <tr>
            <td><code><b>DG.latLng</b>(
                <nobr>&lt;Array&gt; <i>coords</i> )</nobr>
            </code></td>
            <td>Ожидает массив вида <code>[Number, Number]</code> или <code>[Number, Number, Number]</code>
                в качестве аргумента.</td>
        </tr>
        <tr>
            <td><code><b>DG.latLng</b>(
                <nobr>&lt;Object&gt; <i>coords</i> )</nobr>
            </code></td>
            <td>Ожидает объект вида <code>{lat: Number, lng: Number}</code> или
                <code>{lat: Number, lng: Number, alt: Number}</code> в качестве аргумента.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="latlng-equals">
            <td><code><b>equals</b>(
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>otherLatLng</i>,</nobr>
                <nobr>&lt;Number&gt; <i>maxMargin?</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если переданная широта и долгота находится в той же позиции
                (с небольшой погрешностью). Погрешность, используемую по умолчанию, можно изменить
                передав аргумент <code>maxMargin</code>.</td>
        </tr>
        <tr id="latlng-tostring">
            <td><code><b>toString</b>()</code></td>

            <td><code>String</code></td>
            <td>Возвращает строковое представление позиции (удобно при отладке).</td>
        </tr>
        <tr id="latlng-distanceto">
            <td><code><b>distanceTo</b>(
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>otherLatLng</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Возвращает расстояние (в метрах) до переданной широты и долготы, рассчитанное по
                <a target="_blank" href="http://en.wikipedia.org/wiki/Haversine_formula">формуле Haversine</a>.</td>
        </tr>
        <tr id="latlng-wrap">
            <td><code><b>wrap</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td><p>Возвращает новый объект <a href="#dglatlng"><code>LatLng</code></a>, в котором долгота нормализуется
                в диапазон от -180 до 180 градусов.</td>
        </tr>
        <tr id="latlng-tobounds">
            <td><code><b>toBounds</b>(
                <nobr>&lt;Number&gt; <i>sizeInMeters</i> )</nobr>
            </code></td>

            <td><code><a href="#dglatlngbounds">LatLngBounds</a></code></td>
            <td><p>Возвращает новый объект, <a href="#dglatlngbounds"><code>LatLngBounds</code></a> в котором
                каждая из границ отстоит от указанной точки на <code>sizeInMeters</code> метров.</td>
        </tr>
    </tbody>
</table>

#### Свойства

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="latlng-lat">
            <td><code><b>lat</b></code></td>
            <td><code>Number</code></td>
            <td>Широта в градусах.</td>
        </tr>
        <tr id="latlng-lng">
            <td><code><b>lng</b></code></td>
            <td><code>Number</code></td>
            <td>Долгота в градусах.</td>
        </tr>
        <tr id="latlng-alt">
            <td><code><b>alt</b></code></td>
            <td><code>Number</code></td>
            <td>Высота в метрах (опционально).</td>
        </tr>
    </tbody>
</table>

### DG.LatLngBounds

Описывает прямоугольную географическую область на карте.

    var southWest = DG.latLng(54.9801, 82.8974),
        northEast = DG.latLng(54.9901, 82.9074),
        bounds = DG.latLngBounds(southWest, northEast);

Все методы, которые принимают объекты LatLngBounds также принимают их в виде простого массива
(если не указано иное), то есть границы могут быть указаны, как в этом примере:

    map.fitBounds([
        [54.9801, 82.8974],
        [54.9901, 82.9074]
    ]);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="latlngbounds-l-latlngbounds">
            <td><code><b>DG.latLngBounds</b>(
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>southWest</i>,</nobr>
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>northEast</i> )</nobr>
            </code></td>
            <td>Создает объект <a href="#dglatlngbounds"><code>LatLngBounds</code></a>, определяя юго-западный и северо-восточный углы прямоугольника.</td>
        </tr>
        <tr>
            <td><code><b>DG.latLngBounds</b>(
                <nobr>&lt;LatLng[]&gt; <i>latlngs</i>)</nobr>
            </code></td>
            <td>Создает объект <a href="#dglatlngbounds"><code>LatLngBounds</code></a> на основе географических точек,
                которые находятся внутри описываемой области. Удобно использовать, если необходимо подстроить центр
                и масштаб карты с помощью метода <a href="/doc/maps/ru/manual/map#map-fitbounds">fitBounds</a>.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="latlngbounds-extend">
            <td><code><b>extend</b>(
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Расширяет область таким образом, чтобы в них входила переданная точка.</td>
        </tr>
        <tr>
            <td><code><b>extend</b>(
                <nobr>&lt;<a href="#dglatlngbounds">LatLngBounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Расширяет область таким образом, чтобы в них входили переданные границы другой области.</td>
        </tr>
        <tr id="latlngbounds-pad">
            <td><code><b>pad</b>(
                <nobr>&lt;Number&gt; <i>bufferRatio</i> )</nobr>
            </code></td>

            <td><code><a href="#dglatlngbounds">LatLngBounds</a></code></td>
            <td>Возвращает бо́льшую область, увеличенную на заданный процент в каждом из направлений.</td>
        </tr>
        <tr id="latlngbounds-getcenter">
            <td><code><b>getCenter</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td>Возвращает центральную точку области.</td>
        </tr>
        <tr id="latlngbounds-getsouthwest">
            <td><code><b>getSouthWest</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td>Возвращает крайнюю юго-западную точку области.</td>
        </tr>
        <tr id="latlngbounds-getnortheast">
            <td><code><b>getNorthEast</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td>Возвращает крайнюю северо-восточную точку области.</td>
        </tr>
        <tr id="latlngbounds-getnorthwest">
            <td><code><b>getNorthWest</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td>Возвращает крайнюю северо-западную точку области.</td>
        </tr>
        <tr id="latlngbounds-getsoutheast">
            <td><code><b>getSouthEast</b>()</code></td>

            <td><code><a href="#dglatlng">LatLng</a></code></td>
            <td>Возвращает крайнюю юго-восточную точку области.</td>
        </tr>
        <tr id="latlngbounds-getwest">
            <td><code><b>getWest</b>()</code></td>

            <td><code>Number</code></td>
            <td>Возвращает западную границу (долготу) области.</td>
        </tr>
        <tr id="latlngbounds-getsouth">
            <td><code><b>getSouth</b>()</code></td>

            <td><code>Number</code></td>
            <td>Возвращает южную границу (широту) области.</td>
        </tr>
        <tr id="latlngbounds-geteast">
            <td><code><b>getEast</b>()</code></td>

            <td><code>Number</code></td>
            <td>Возвращает восточную границу (долготу) области.</td>
        </tr>
        <tr id="latlngbounds-getnorth">
            <td><code><b>getNorth</b>()</code></td>

            <td><code>Number</code></td>
            <td>Возвращает северную границу (широту) области.</td>
        </tr>
        <tr id="latlngbounds-contains">
            <td><code><b>contains</b>(
                <nobr>&lt;<a href="#dglatlngbounds">LatLngBounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если область содержит переданные границы.</td>
        </tr>
        <tr id="latlngbounds-contains">
            <td><code><b>contains</b>(
                <nobr>&lt;<a href="#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
             </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если область содержит переданную точку.</td>
        </tr>
        <tr id="latlngbounds-intersects">
            <td><code><b>intersects</b>(
                <nobr>&lt;<a href="#dglatlngbounds">LatLngBounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если границы области пересекают переданные границы хотя бы в одной точке.</td>
        </tr>
        <tr id="latlngbounds-overlaps">
            <td><code><b>overlaps</b>(
                <nobr>&lt;<a href="#dgbounds">Bounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если границы области перекрывают переданные границы в некотором пространстве.</td>
        </tr>
        <tr id="latlngbounds-tobboxstring">
            <td><code><b>toBBoxString</b>()</code></td>

            <td><code>String</code></td>
            <td>Возвращает строку с координатами границ в формате <code>&#39;southwest_lng,southwest_lat,northeast_lng,northeast_lat&#39;</code>.
                Удобно использовать для отправки запросов к веб-сервисам, возвращающим геоданные.</td>
        </tr>
        <tr id="latlngbounds-equals">
            <td><code><b>equals</b>(
                <nobr>&lt;<a href="#dglatlngbounds">LatLngBounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если координаты текущей прямоугольной области эквивалентны переданным
                (с небольшой погрешностью).</td>
        </tr>
        <tr id="latlngbounds-isvalid">
            <td><code><b>isValid</b>()</code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если свойства объекта (данные границ) инициализированы должным образом.</td>
        </tr>
    </tbody>
</table>

### DG.Point

Точка с пиксельными координатами x и y.

    var point = DG.point(200, 300);

Все методы, которые принимают объекты <a href="#dgpoint"><code>Point</code></a>, также принимают
координаты в виде простого массива (если не указано иное), то есть данные записи эквивалентны:

    map.panBy([200, 300]);
    map.panBy(DG.point(200, 300));

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="point-l-point">
            <td><code><b>DG.point</b>(
                <nobr>&lt;Number&gt; <i>x</i>,</nobr>
                <nobr>&lt;Number&gt; <i>y</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>round?</i> )</nobr>
            </code></td>
            <td>Создает объект Point с заданными координатами <code>x</code> и <code>y</code>, при необходимости
                округляя значения (если <code>round</code> установлен в <code>true</code>).</td>
        </tr>
        <tr id="point-l-point">
            <td><code><b>DG.point</b>(
                <nobr>&lt;Number[]&gt; <i>coords</i>)</nobr>
            </code></td>
            <td>Ожидает массив вида <code>[x, y]</code>.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="point-clone">
            <td><code><b>clone</b>()</nobr></code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает копию оригинального объекта.</td>
        </tr>
        <tr id="point-add">
            <td><code><b>add</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>otherPoint</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает результат сложения координат заданной точки и текущей.</td>
        </tr>
        <tr id="point-subtract">
            <td><code><b>subtract</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>otherPoint</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает результат вычитания координат заданной точки из текущей.</td>
        </tr>
        <tr id="point-divideby">
            <td><code><b>divideBy</b>(
                <nobr>&lt;Number&gt; <i>num</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает результат деления координат текущей точки на произвольное число.</td>
        </tr>
        <tr id="point-multiplyby">
            <td><code><b>multiplyBy</b>(
                <nobr>&lt;Number&gt; <i>num</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает результат умножения координат текущей точки на произвольное число.</td>
        </tr>
        <tr id="point-scaleby">
            <td><code><b>scaleBy</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>scale</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает новую точку, каждая координата которой получена умножением на соответствующую координату
                <code>scale</code>. В терминах линейной алгебры, данная операция производит умножение на
                <a href="https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation">матрицу масштабирования</a>,
                заданную <code>scale</code>.</td>
        </tr>
        <tr id="point-unscaleby">
            <td><code><b>unscaleBy</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>scale</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Обратная операция, относительно <code>scaleBy</code>.</td>
        </tr>
        <tr id="point-round">
            <td><code><b>round</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает копию оригинального объекта с округленными координатами.</td>
        </tr>
        <tr id="point-floor">
            <td><code><b>floor</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает копию оригинального объекта с координатами, округленными вниз.</td>
        </tr>
        <tr id="point-ceil">
            <td><code><b>ceil</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает копию оригинального объекта с координатами, округленными вверх.</td>
        </tr>
        <tr id="point-distanceto">
            <td><code><b>distanceTo</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>otherPoint</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Возвращает декартово расстояние между текущй и заданной точками.</td>
        </tr>
        <tr id="point-equals">
            <td><code><b>equals</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>otherPoint</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если заданная точка имеет аналогичные координаты.</td>
        </tr>
        <tr id="point-contains">
            <td><code><b>contains</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>otherPoint</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если обе координаты заданной точки меньше (в абсолютных величинах) координат
                текущей точки.</td>
        </tr>
        <tr id="point-tostring">
            <td><code><b>toString</b>()</code></td>

            <td><code>String</code></td>
            <td>Возвращает строковое представление точки (удобно для отладки).</td>
        </tr>
    </tbody>
</table>

#### Свойства

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>x</b></code></td>
            <td><code>Number</code></td>
            <td>Координата x.</td>
        </tr>
        <tr>
            <td><code><b>y</b></code></td>
            <td><code>Number</code></td>
            <td>Координата y.</td>
        </tr>
    </tbody>
</table>

### DG.Bounds

Описывает прямоугольную область на карте в пиксельных координатах.

    var p1 = DG.point(10, 10),
        p2 = DG.point(40, 60),
        bounds = DG.bounds(p1, p2);

Все методы, которые принимают объекты <a href="#dgpoint"><code>Point</code></a> также принимают их в виде простого массива
(если не указано иное), то есть границы могут быть указаны, как в этом примере:

    otherBounds.intersects([[10, 10], [40, 60]]);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="bounds-l-bounds">
            <td><code><b>DG.bounds</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>topLeft</i>,</nobr>
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>bottomRight</i> )</nobr>
            </code></td>
            <td>Создает объект Bounds на основе переданных координат (обычно, координат левого-верхнего и правого-нижнего углов).</td>
        </tr>
        <tr id="bounds-l-bounds">
            <td><code><b>DG.bounds</b>(
                <nobr>&lt;Point[]&gt; <i>points</i> )</nobr>
            </code></td>
            <td>Создает объект Bounds на основе массива координат переданных точек.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="bounds-extend">
            <td><code><b>extend</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>point</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Расширяет область таким образом, чтобы в нее входила переданная точка.</td>
        </tr>
        <tr id="bounds-getcenter">
            <td><code><b>getCenter</b>(
                <nobr>&lt;Boolean&gt; <i>round?</i> )</nobr>
            </code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает центральную точку области.</td>
        </tr>
        <tr id="bounds-getbottomleft">
            <td><code><b>getBottomLeft</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает координаты левого-нижнего угла области.</td>
        </tr>
        <tr id="bounds-gettopright">
            <td><code><b>getTopRight</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает координаты правого-верхнего угла области.</td>
        </tr>
        <tr id="bounds-getsize">
            <td><code><b>getSize</b>()</code></td>

            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Возвращает размер области.</td>
        </tr>
        <tr id="bounds-contains">
            <td><code><b>contains</b>(
                <nobr>&lt;<a href="#dgbounds">Bounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если область содержит переданные границы.</td>
        </tr>
        <tr id="bounds-contains">
            <td><code><b>contains</b>(
                <nobr>&lt;<a href="#dgpoint">Point</a>&gt; <i>point</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если область содержит переданную точку.</td>
        </tr>
        <tr id="bounds-intersects">
            <td><code><b>intersects</b>(
                <nobr>&lt;<a href="#dgbounds">Bounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если границы области пересекают переданные границы хотя бы в одной точке.</td>
        </tr>
        <tr id="bounds-overlaps">
            <td><code><b>overlaps</b>(
                <nobr>&lt;<a href="#dgbounds">Bounds</a>&gt; <i>otherBounds</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если границы области перекрывают переданные границы в некотором пространстве.</td>
        </tr>
    </tbody>
</table>

#### Свойства

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="bounds-min">
            <td><code><b>min</b></code></td>
            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Левый верхний угол прямоугольной области.</td>
        </tr>
        <tr id="bounds-max">
            <td><code><b>max</b></code></td>
            <td><code><a href="#dgpoint">Point</a></code></td>
            <td>Правый нижний угол прямоугольной области.</td>
        </tr>
	</tbody>
</table>


================================================
FILE: src/doc/ru/manual/controls.md
================================================
## Элементы управления

Элементы управления — это компоненты интерфейса, с помощью которых пользователь может взаимодействовать с картой.

{toc}

### DG.Control.Zoom

Базовый элемент управления масштабом с двумя кнопками (приблизить и отдалить). Добавляется на карту по умолчанию,
если не передана <a href="/doc/maps/ru/manual/map#map-zoomcontrol">опция <code>zoomControl</code></a> со значением <code>false</code>.
Расширяет <a href="/doc/maps/ru/manual/base-classes#dgcontrol"><code>DG.Control</code></a>.

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-zoom-l-control-zoom">
            <td><code><b>DG.control.zoom</b>(
                <nobr>&lt;<a href="#control-zoom-option">DG.Control.Zoom options</a>&gt; <i>options</i> )</nobr>
            </code></td>
            <td>Создает элемент управления масштабом.</td>
	    </tr>
	</tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-zoom-zoomintext">
            <td><code><b>zoomInText</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;+&#x27;</code></td>
            <td>Текст кнопки &#39;приблизить&#39;.</td>
        </tr>
        <tr id="control-zoom-zoomintitle">
            <td><code><b>zoomInTitle</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;Zoom in&#x27;</code></td>
            <td>Значение атрибута title для конпки &#39;приблизить&#39;.</td>
        </tr>
        <tr id="control-zoom-zoomouttext">
            <td><code><b>zoomOutText</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;-&#x27;</code></td>
            <td>Текст кнопки &#39;Отдалить&#39;.</td>
        </tr>
        <tr id="control-zoom-zoomouttitle">
            <td><code><b>zoomOutTitle</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;Zoom out&#x27;</code></td>
            <td>Значение атрибута title для конпки &#39;отдалить&#39;.</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Методы

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.Attribution

Позволяет показать информацию об авторстве в небольшом текстовом контейнере на карте. Добавляется на карту по умолчанию,
если значение опции <a href="/doc/maps/ru/manual/map#map-attributioncontrol"><code>attributionControl</code></a>
не выставлено в <code>false</code>. Компонует итоговый текст из слоев, вызывая их метод
<a href="/doc/maps/ru/manual/base-classes#layer-getattribution"><code>getAttribution</code></a>.
Расширяет <a href="/doc/maps/ru/manual/base-classes#dgcontrol"><code>DG.Control</code></a>.

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-attribution-l-control-attribution">
            <td><code><b>DG.control.attribution</b>(
                <nobr>&lt;<a href="#control-attribution-option">DG.Control.Attribution options</a>&gt; <i>options</i> )</nobr>
            </code></td>
            <td>Создает элемент с информацией об авторстве.</td>
        </tr>
	</tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-attribution-prefix">
            <td><code><b>prefix</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;Leaflet&#x27;</code></td>
            <td>Текст в формате HTML, который будет отображен перед информацией об авторстве.
                Для отключения необходимо передать <code>false</code>.</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Методы

<table>
    <thead>
	<tr>
		<th>Метод</th>
		<th>Возвращает</th>
		<th>Описание</th>
	</tr>
	</thead>
	<tbody>
        <tr id="control-attribution-setprefix">
            <td><code><b>setPrefix</b>(
                <nobr>&lt;String&gt; <i>prefix</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет текст перед информацией об авторстве.</td>
        </tr>
        <tr id="control-attribution-addattribution">
            <td><code><b>addAttribution</b>(
                <nobr>&lt;String&gt; <i>text</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет информацию об авторстве (например, <code>&#39;Картографические данные 2GIS&#39;</code>).</td>
        </tr>
        <tr id="control-attribution-removeattribution">
            <td><code><b>removeAttribution</b>(
                <nobr>&lt;String&gt; <i>text</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Удаляет информацию об авторстве.</td>
        </tr>
    </tbody>
</table>

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.Scale

Показывает масштаб карты в метрической (метры, километры) и английской (мили, футы) системах измерений.
Расширяет <a href="/doc/maps/ru/manual/base-classes#dgcontrol"><code>DG.Control</code></a>.

    DG.control.scale().addTo(map);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-scale-l-control-scale">
            <td><code><b>DG.control.scale</b>(
                <nobr>&lt;<a href="#control-scale-option">DG.Control.Scale options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Создает индикатор масштаба.</td>
        </tr>
	</tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-scale-maxwidth">
            <td><code><b>maxWidth</b></code></td>
            <td><code>Number </code></td>
            <td><code>100</code></td>
            <td>Максимальная ширина элемента в пикселях.</td>
        </tr>
        <tr id="control-scale-metric">
            <td><code><b>metric</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>True</code></td>
            <td>Включает или отключает метрическую систему измерений (метры, километры).</td>
        </tr>
        <tr id="control-scale-imperial">
            <td><code><b>imperial</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>True</code></td>
            <td>Включает или отключает английскую систему измерений (мили, футы).</td>
        </tr>
        <tr id="control-scale-updatewhenidle">
            <td><code><b>updateWhenIdle</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>При значении <code>true</code>, элемент будет обновляться только при возникновении события
                <a href="/doc/maps/ru/manual/map#map-moveend"><code>moveend</code></a>, в противном случае, при каждом событии
                <a href="/doc/maps/ru/manual/map#map-move"><code>move</code></a>.</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Методы

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.Ruler

Кнопка включения отображения линейки для измерения расстояний на карте.
Расширяет <a href="/doc/maps/ru/manual/base-classes#dgcontrol"><code>DG.Control</code></a>.

    DG.control.ruler().addTo(map);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-ruler-l-control-ruler">
            <td><code><b>DG.control.ruler</b>(
                <nobr>&lt;<a href="#control-ruler-option">DG.Control.Ruler options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Создает кнопку включения отображения линейки.</td>
        </tr>
	</tbody>
</table>

#### Опции

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Методы

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.Traffic

Кнопка включения отображения слоя пробок на карте.
Расширяет <a href="/doc/maps/ru/manual/base-classes#dgcontrol"><code>DG.Control</code></a>.

    DG.control.traffic().addTo(map);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-traffic-l-control-traffic">
            <td><code><b>DG.control.traffic</b>(
                <nobr>&lt;<a href="#control-traffic-option">DG.Control.Traffic options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Создает элемент управления слоем пробок.</td>
        </tr>
	</tbody>
</table>

#### Опции

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Методы

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.Fullscreen

Кнопка включения полноэкранного отображения карты, повторный клик в кнопку
восстанавливает исходный размер карты. Добавляется на карту по умолчанию,
если не передана опция <code>fullscreenControl</code> со значением <code>false</code>.
Расширяет <a href="/doc/maps/ru/manual/base-classes#dgcontrol"><code>DG.Control</code></a>.

    DG.control.fullscreen().addTo(map);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-fullscreen-l-control-fullscreen">
            <td><code><b>DG.control.fullscreen</b>(
                <nobr>&lt;<a href="#control-fullscreen-option">DG.Control.Fullscreen options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Создает элемент управления полноэкранным режимом.</td>
        </tr>
	</tbody>
</table>

#### Опции

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Методы

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

### DG.Control.LocationControl

Элемент управление (кнопка), при клике на которую определяется и отображается текущее месторасположение пользователя.
Если API геолокации не поддерживается устройством, тогда элемент управления не выводится.

    DG.control.location().addTo(map);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-location-l-control-location">
            <td><code><b>DG.control.location</b>(
                <nobr>&lt;<a href="#control-location-option">DG.Control.LocationControl options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Создает элемент управления геопозиционированием.</td>
        </tr>
	</tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="control-location-drawcircle">
            <td><code><b>drawCircle</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Будет ли отображаться круг, показывающий точность определения месторасположения.</td>
        </tr>
        <tr id="control-location-follow">
            <td><code><b>follow</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Динамическое обновление месторасположения пользователя, работает, если <code>watch</code> и
                <code>setView</code> выставлены в <code>true</code>.</td>
        </tr>
        <tr id="control-location-stopfollowingondrag">
            <td><code><b>stopFollowingOnDrag</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Включает или отключает обновление месторасположения пользователя при перетаскивании карты.</td>
        </tr>
        <tr id="control-location-metric">
            <td><code><b>metric</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Использовать метрические или английские единицы измерения.</td>
        </tr>
        <tr id="control-location-locateoptions">
            <td><code><b>locateOptions</b></code></td>
            <td><code>Object </code></td>
            <td><code></code></td>
            <td>См. <a href="/doc/maps/ru/manual/map#geolocation-options">geo-location options</a>.</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->

#### Методы

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgcontrol">Control</a> <!-- TODO: include options -->


================================================
FILE: src/doc/ru/manual/dg-ajax.md
================================================
## Асинхронные запросы (AJAX)

{toc}

### DG.ajax

Функция DG.ajax позволяет отправлять кросс-доменные AJAX запросы.

    var promise = DG.ajax('http://www.geonames.org/postalCodeLookupJSON', {
        type: 'get',
        data: {
            postalcode: 10504,
            country: 'US'
        },
        success: function(data) {
            console.log('success', data);
        },
        error: function(error) {
            console.log('error', error);
        }
    });

    // для отмены запроса:
    // promise.abort();

#### Методы

<table>
    <thead>
        <tr>
            <th>Вызов</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.ajax</b>(
                <nobr>&lt;String&gt; <i>url</i>,</nobr>
                <nobr>&lt;<a href="#опции">Ajax options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td><code>Promise</code></td>
            <td>Отправляет запрос на сервер и возвращает объект Promise с методом abort, с помощью
                которого можно прервать отправку запроса. В качестве входящих параметров принимает URL,
                на который будет отправлен запрос и необязательный объект опций.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>data</b></code></td>
            <td><code>Object</code></td>
            <td><code>null</code></td>
            <td>Данные, которые будут переданы на сервер.</td>
        </tr>
        <tr>
            <td><code><b>type</b></code></td>
            <td><code>String</code></td>
            <td><code>get</code></td>
            <td>Тип запроса ('get', 'post' или 'jsonp').</td>
        </tr>
        <tr>
            <td><code><b>success</b></code></td>
            <td><code>Function</code></td>
            <td><code>null</code></td>
            <td>Функция, которая срабатывает в случае успешного ответа сервера.
                В качестве параметра принимает полученные данные.</td>
        </tr>
        <tr>
            <td><code><b>error</b></code></td>
            <td><code>Function</code></td>
            <td><code>null</code></td>
            <td>Функция, которая срабатывает при возникновении ошибки.
                В качестве параметра принимает информацию об ошибке.</td>
        </tr>
        <tr>
            <td><code><b>url</b></code></td>
            <td><code>String</code></td>
            <td><code>null</code></td>
            <td>URL, на который будет отправлен запрос.</td>
        </tr>
        <tr>
            <td><code><b>timeout</b></code></td>
            <td><code>Number</code></td>
            <td><code>null</code></td>
            <td>Время ожидания запроса (в миллисекундах).</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/dg-entrance.md
================================================
## DG.Entrance

Позволяет отобразить вход в здание. Класс поддерживает простейшую анимацию и отображение сразу нескольких входов. Сами
объекты входов представляют собой стрелки, которые изменяют свой масштаб вместе с изменением масштаба карты, но не ниже
16 уровня, после которого стрелки исчезают с карты (до возвращения приемлемого значения уровня масштабирования).

{toc}

### DG.Entrance

#### Пример использования

Создание и отображение входов в здание:

    var options = {vectors: [
        "LINESTRING(82.897079 54.980906,82.897191 54.980844)",
        "LINESTRING(82.897933 54.980649,82.898045 54.980587)",
        "LINESTRING(82.897071 54.980122,82.897226 54.98013)",
        "LINESTRING(82.897354 54.979515,82.89741 54.979599)",
        "LINESTRING(82.898498 54.979826,82.898386 54.979889)"
    ]}
    DG.entrance(options).addTo(map).show(true);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Использование</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Entrance</b>(
                <nobr>&lt;<a href="#entrance-options">Entrance options</a>&gt; <i>options</i> )</nobr>
            </code></td>
            <td><code>DG.entrance(&hellip;)</code></td>
            <td>Создает объект входа на основе переданных опций.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>vectors</b></code></td>
            <td><code>Array</td>
            <td><code>[]</code></td>
            <td><b>(обязательный параметр)</b>Массив векторов, описывающих входы в здание. В массиве можно передать
                несколько значений, если существует более одного входа в здание. Каждый элемент должен представлять
                собой строку в WKT-формате: LINESTRING(lng0 lat0,lng1 lat1[,... lngN latN]), где последняя пара координат
                должна представлять собой непосредственно точку входа в здание, а предыдущие координаты - маршрут до этой точки.
                На всем протяжении маршрута не должно быть взаимных пересечений.</td>
        </tr>
        <tr>
            <td><code><b>fillColor</b></code></td>
            <td><code>String</td>
            <td><code>#0085a0</code></td>
            <td>Цвет заполнения стрелок.</td>
        </tr>
        <tr>
            <td><code><b>strokeColor</b></code></td>
            <td><code>String</td>
            <td><code>#ffffff</code></td>
            <td>Цвет обводки стрелок.</td>
        </tr>
        <tr>
            <td><code><b>enableAnimation</b></code></td>
            <td><code>Boolean</td>
            <td><code>true</code></td>
            <td>Анимировать ли отображение стрелок при изменении уровней масштаба карты и начальном показе.</td>
        </tr>
        <tr>
            <td><code><b>interactive</b></code></td>
            <td><code>Boolean</td>
            <td><code>false</code></td>
            <td>Если значение false, тогда обработчик действий мыши не вызывается.</td>
        </tr>
        <tr>
            <td><code><b>autoClose</b></code></td>
            <td><code>Boolean</td>
            <td><code>true</code></td>
            <td>Если значение true, то входы пропадут с карты после добавления новых слоев.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>addTo</b>(
                <nobr>&lt;<a href="#map">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет объект входов на карту.</td>
        </tr>
        <tr>
            <td><code><b>removeFrom</b>(
                <nobr>&lt;<a href="#map">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Удаляет объект входов с карты.</td>
        </tr>
        <tr>
            <td><code><b>show</b>(
                <nobr>&lt;fitBounds&gt; <i>boolean</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Отображает входы на карте. Если <code>fitBounds</code> установлен в <code>true</code>, тогда границы карты
                (и уровень масштаба) подстраиваются таким образом, чтобы пользователь увидел все входы на одном экране.</td>
        </tr>
        <tr>
            <td><code><b>hide</b>()</code></td>

            <td><code>this</code></td>
            <td>Скрывает входы. Сами объекты не удаляются с карты и входы могут быть повторно отображены путем вызова метода
                <code>show()</code>.</td>
        </tr>
        <tr>
            <td><code><b>isShown</b>()</code></td>
            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если входы в данный момент отображаются на карте.</td>
        </tr>
        <tr>
            <td><code><b>setFillColor</b>()</code></td>
            <td><code>String</code></td>
            <td>Изменяет цвет заполнения стрелок.</td>
        </tr>
        <tr>
            <td><code><b>setStrokeColor</b>()</code></td>
            <td><code>String</code></td>
            <td>Изменяет цвет обводки стрелок.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/dg-external-modules.md
================================================
## Внешние модули

Кроме возможности подключить один из <a href="/doc/maps/ru/manual/dg-loading#loading-pkg">пакетов</a> модулей 2ГИС,
вы можете загружать модули других разработчиков со сторонних серверов. API карт совместим с большинством
<a target="_blank" href="http://leafletjs.com/plugins.html">модулей библиотеки</a> Leaflet.
Также вы можете разработать и подключить
<a href="https://github.com/2gis/maps-api-2.0/blob/master/CONTRIBUTING.md#%D0%9A%D0%B0%D0%BA-%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%D1%82%D1%8C-%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8C" target="_blank">собственный модуль</a>.

{toc}

### Подключение

Для подключения внешних модулей используется функция <code>DG.plugin</code>.
Ниже мы рассмотрим несколько примеров ее использования.

Использование функции <code>DG.plugin</code> в случае, когда модуль должен быть
загружен до начала инициализации карты:

    // загрузка кода API карт
    DG.then(function() {
        // загрузка кода модуля
        return DG.plugin('https://raw.github.com/mlevans/leaflet-hash/master/leaflet-hash.js');
    })
    .then(function() {
        // инициализация карты
        var map = DG.map('map', {
            'center': [54.98, 82.89],
            'zoom': 13
        });
        // инициализация модуля
        L.hash(map);
    });

Если модуль не нужен на начальном этапе работы с картой, тогда можно использовать его отложенную
загрузку и инициализацию (например, при клике на кнопку):

    // загрузка кода API карт
    DG.then(function() {
        // инициализация карты
        map = DG.map('map', {
            'center': [54.98, 82.89],
            'zoom': 13
        });
    });

    // код, который может быть вызван по требованию
    DG.then(function() {
        // загрузка кода модуля
        return DG.plugin('https://raw.github.com/mlevans/leaflet-hash/master/leaflet-hash.js');
    }).then(function () {
        // инициализация модуля
        L.hash(map);
    });

### DG.plugin

Отвечает за загрузку внешних модулей. Параметры функции:

<table>
    <thead>
        <tr>
            <th>Вызов</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code>DG.plugin</b>(
                <nobr>&lt;String&gt; <i>url</i>&nbsp;|&nbsp;</nobr>
                <nobr>&lt;Array&gt; <i>[&lt;String&gt; url, &lt;String&gt; url, ...]</i></nobr>&nbsp;)
            </code></td>
            <td><code>Promise</code></td>
            <td>Загружает модули. В качестве параметров должны быть указкны прямые ссылки на js и css файлы.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/dg-label.md
================================================
## Подсказки

{toc}

### DG.Label

Класс <code>DG.Label</code> реализует небольшую подсказку, которая может появляться над определенным объектом на карте
(над маркером или векторным слоем, например). Также, подсказки могут отображаться не только, при наведении курсора мыши
на объект, а постоянно, такие подсказки называются статическими.

#### Пример использования

Включить отображение подсказки при наведении курсора мыши на маркер довольно просто:

    DG.marker([54.9502, 82.8380], {
        label : 'Я подсказка!'
    }).addTo(map);

Для векторных слоев, подсказку можно указать таким образом, например:

    DG.polyline([
        [55.02, 83.02],
        [54.97, 83.03],
        [54.95, 83.01],
        [54.98, 82.97]
    ], {
        label: 'Я подсказка!'
    }).addTo(map);

Для добавления подсказки к уже созданному объекту, следует вызвать метод <code>bindLabel</code>:

    var marker = DG.marker([54.9502, 82.8980]).addTo(map);
    marker.bindLabel('Я статическая подсказка!', { static: true });

<!--
TODO: JSAPI-3564
Отображение автономной статической подсказки на карте:

    DG.label('Я автономная подсказка!')
        .setLatLng([54.9502, 82.8980]);
        .addTo(map);

#### Создание
...
-->

#### Опции

При вызове метода <code>bindLabel</code>, вы можете задать следующие опции для всплывающей подсказки:

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><b><code>offset</code></b></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td><nobr><code>Point(12, 15)</code></nobr></td>
            <td>Смещение контейнера всплывающей подсказки относительно позиции курсора (позиции маркера в случае
                использования с маркером).</td>
        </tr>
        <tr>
            <td><b><code>className</code></b></td>
            <td><code>String</code></td>
            <td><code>'dg-label'</code></td>
            <td>CSS класс который будет присвоен DOM элементу всплывающей подсказки.</td>
        </tr>
        <tr id="label-static">
            <td><b><code>static</code></b></td>
            <td><code>Boolean</code></td>
            <td><code>false</code></td>
            <td>Если задано значение <code>true</code>, тогда всплывающая подсказка будет отображаться постоянно
                (эта опция доступна только для подсказки у маркера).</td>
        </tr>
        <tr id="label-textdirection">
            <td><code><b>textDirection</b></code></td>
            <td><code>string</code></td>
            <td><code>'auto'</code></td>
            <td>Направление текста подсказки. Может принимать одно из следующих значений: <code>'auto'</code>,
                <code>'rtl'</code>, <code>'ltr'</code>.</td>
        </tr>
    </tbody>
</table>

<!--
TODO: JSAPI-3564
#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>setContent</b>(&lt;String&gt; content)</code></td>
            <td><code>this</code></td>
            <td>Устанавливает содержимое всплывающей подсказки.</td>
        </tr>
        <tr>
            <td><code><b>setLatLng</b>(&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; latlng)</code></td>
            <td><code>this</code></td>
            <td>Устанавливает географические координаты подсказки.</td>
        </tr>
        <tr>
            <td><code><b>getLatLng</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Возвращает географические координаты подсказки.</td>
        </tr>
    </tbody>
</table>
-->


================================================
FILE: src/doc/ru/manual/dg-loading.md
================================================
## Подключение API

{toc}

### Описание

Работа с картой возможна только после того, как в браузер будет загружен код API карт.
Есть несколько способов его загрузки.

### Простой способ

Сперва подключим API карт, поместив в секцию <code>head</code> HTML-страницы следующий код:

    <script src="https://maps.api.2gis.ru/2.0/loader.js?pkg=full"></script>

Затем воспользуемся функцией <code>DG.then</code>, в которую поместим код инициализации карты:

    DG.then(function() {
        map = DG.map('map', {
            'center': [54.98, 82.89],
            'zoom': 13
        });
    });

Внутри себя эта функция добавляет обработчик события загрузки страницы. Именно такой способ
рассматривался в разделе [«Быстрый старт»](/doc/maps/ru/quickstart).

### npm

API карт можно подключить через npm:

    $ npm i 2gis-maps

После установки пакета подключим его через <code>require</code>:

    var DG = require('2gis-maps');
    var map = DG.map('map', {
        'center': [54.98, 82.89],
        'zoom': 13
    });

Обратите внимание, что при использовании npm-пакета использовать <code>DG.then</code> не нужно.

### Загрузка по требованию

Вы можете загрузить API карт именно в тот момент, когда карта станет нужна. Для этого в URL
подключения API необходимо добавить параметр <code>lazy=true</code>:

    <script src="https://maps.api.2gis.ru/2.0/loader.js?pkg=full&lazy=true"></script>

Затем в нужный момент времени (например, при нажатии на кнопку) необходимо вызвать функцию DG.then:

    DG.then(function() {
        map = DG.map('map', {
            'center': [54.98, 82.89],
            'zoom': 13
        });
    });

### Опции подключения

Ниже описаны все опции, которые может принимать URL загрузки API карт:

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="loading-pkg">
            <td><code>pkg</code></td>
            <td><code>full</code></td>
            <td>Пакет загружаемых модулей. На данный момент поддерживается 2 пакета:
                <code>full</code> — все модули API; <code>basic</code> — базовая функциональность
                (попапы, маркеры, векторные объекты).</td>
        </tr>
        <tr>
            <td><code>skin</code></td>
            <td><code>dark</code></td>
            <td>Тема управляющих элементов (светлая или темная). Принимает значение
                <code>light</code> или <code>dark</code>.</td>
        </tr>
        <tr>
            <td><code>lazy</code></td>
            <td><code>false</code></td>
            <td>Если указать значение <code>true</code>, тогда API карт загрузится отложенно,
                при первом вызове <code>DG.then</code>.</td>
        </tr>
    </tbody>
</table>

### Функция DG.then

Как было описано ранее, функция <code>DG.then</code> отвечает за отслеживание момента загрузки API карт
и добавление обработчиков этого действия. Параметры функции:

<table>
    <thead>
        <tr>
            <th>Вызов</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code>DG.then</b>(
                <nobr>&lt;Function&gt; <i>resolve</i>,</nobr>
                <nobr>&lt;Function&gt; <i>reject</i></nobr>&nbsp;)
            </code></td>
            <td><code>Promise</code></td>
            <td>Регистрирует обработчики загрузки API. Пареметры: <code>resolve</code> — функция,
                срабатывающая при успешной загрузке API карт, <code>reject</code> — функция,
                срабатывающая в случае ошибки сервера.</td>
        </tr>
    </tbody>
</table>

Вызов функции <code>DG.then</code> в любой момент после загрузки API мгновенно выполнит обработчик.


================================================
FILE: src/doc/ru/manual/dg-locale.md
================================================
## Локализация

{toc}

### Описание

API карт предоставляет возможность отображения элементов пользовательского интерфейса на нескольких языках.

По умолчанию задается такой же язык, как и у корневого тега html:

    <html lang="it">
        <head></head>
        <body></body>
    </html>

Если язык в корневом теге не указан, тогда будет использоваться язык по умолчанию — русский.

Получить или динамически изменить язык можно с помощью соответствующих методов карты
<a href="/doc/maps/ru/manual/map#map-getlang">getLang</a> и <a href="/doc/maps/ru/manual/map#map-setlang">setLang</a>:

    map.setLang('it');
    map.getLang(); // вернет 'it'

или проинициализировав карту со следующей опцией <a href="/doc/maps/ru/manual/map#map-currentlang">currentLang</a>.

На данный момент поддерживаются следующие языки:

* en &mdash; английский;
* ru &mdash; русский;
* it &mdash; итальянский;
* cs &mdash; чешский;
* es &mdash; испанский;
* ar &mdash; арабский.

### DG.Locale

Осуществляет <a href="/doc/maps/ru/manual/dg-locale">перевод пользовательского интерфейса</a>.

Добавляет в карту два метода: <a href="/doc/maps/ru/manual/map#map-setlang">setLang</a> и
<a href="/doc/maps/ru/manual/map#map-getlang">getLang</a>. Также имеется объект DG.Locale, который можно подмешать
в любой <a href="/doc/maps/ru/manual/dg-external-modules">внешний модуль</a>, после чего в нем появится метод t,
с помощью которого можно осуществить перевод. Классы модулей, к которым примешивается DG.Locale должны
содержать внутри себя свойство <code>_map</code> и статическое свойство <code>Dictionary</code>.

Базовым для всех словарей является словарь <code>DG.Dictionary</code>, в котором хранятся правила перевода слов во
множественные формы (plural rules). При создании модуля, использующего свои словари, необходимо их разместить
в папке lang. К примеру, если вы будете использовать итальянский и русский языки, тогда необходимо создать
файлы <code>lang/it.js</code> и <code>lang/ru.js</code>. Примеры создания словарей рассмотрены ниже.

#### Пример использования

Подмешивание (mixin) возможности локализации в модуль:

    DG.LocaleExample = DG.Control.extend({
        includes: DG.Locale,
        statics: {
            Dictionary: {}
        }
        ...
    }

Подписка на событие langchange:

    this._map.on('langchange', this._updateText, this);

Перевод строки на текущий язык карты:

    container.innerHTML = this.t("{n} people", 16700000) + ' ' + this.t("regularly use 2GIS");

Создание собственных словарей на итальянском и русском языках:

Cодержимое файла lang/it.js:

    DG.LocaleExample.Dictionary.it = DG.extend({
        "{n} people" : ["{n} utente", "{n} utenti"],
        "regularly use 2GIS" : "utilizzano regolarmente 2GIS"
    }, DG.Dictionary.it);

Cодержимое файла lang/ru.js:

     DG.LocaleExample.Dictionary.ru = DG.extend({
        "{n} people" : ["{n} пользователь", "{n} пользователя", "{n} пользователей"],
        "regularly use 2GIS" : "регулярно используют 2GIS"
    }, DG.Dictionary.ru);


================================================
FILE: src/doc/ru/manual/dg-metalayers.md
================================================
## Слои с мета-информацией

Позволяет создавать дополнительные слои с мета-информацией и добавлять их на карту.

{toc}

### DG.Meta.layer

Наследует от <a href="/doc/maps/ru/manual/base-classes#dglayer"><code>DG.Layer</code></a>.

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Использование</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Meta.layer</b>(
                <nobr>&lt;String&gt; <i>source</i>,</nobr>
                <nobr>&lt;<a href="#опции">DG.Meta.layer options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td><code>DG.Meta.layer(&hellip;)</code></td>
            <td>Создает дополнительный слой с метаинформацией. Принимает в качестве параметра source URL,
                по которому доступны тайлы допслоя.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>tileSize</b></code></td>
            <td><code>Number</code></td>
            <td><code>256</code></td>
            <td>Размер тайла (ширина и высота в пикселях, предполагается что тайл квадратный).</td>
        </tr>
        <tr>
            <td><code><b>minZoom</b></code></td>
            <td><code>Number</code></td>
            <td><code>0</code></td>
            <td>Минимальный уровень зума.</td>
        </tr>
        <tr>
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number</code></td>
            <td><code>18</code></td>
            <td>Максимальный уровень зума.</td>
        </tr>
        <tr>
            <td><code><b>zoomOffset</b></code></td>
            <td><code>Number</code></td>
            <td><code>0</code></td>
            <td>Значение, на которое будет смещен уровень масштабирования в адресе тайла.</td>
        </tr>
        <tr>
            <td><code><b>eventBubbling</b></code></td>
            <td><code>String</code></td>
            <td><code><span class="string">'transparent'</span>||<span class="string">'layer'</span></td>
            <td>Способ, которым мета-слой обрабатывает события. Принимает значения <b>layer</b>
                или <b>transparent</b> (по-умолчанию):<ul><li>transparent &mdash; мета-слой принимает
                все события и прокидывает их на карту</li><li>layer &mdash; мета-слой принимает
                события и останавливает их после обработки</li></ul></td>
        </tr>
    </tbody>
</table>

#### События

Вы можете подписаться на следующие события, используя
<a href="/doc/maps/ru/manual/base-classes#dgevented">эти методы</a>.

<table>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>mouseover</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#metaevent">MetaEvent</a></code>
            <td>Вызывается при наведении курсором мыши на объект допслоя.</td>
        </tr>
        <tr>
            <td><code><b>mouseout</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#metaevent">MetaEvent</a></code>
            <td>Вызывается при когда курсор мыши покидает границы объекта допслоя.</td>
        </tr>
        <tr>
          <td><code><b>mousemove</b></code></td>
          <td><code><a href="/doc/maps/ru/manual/base-classes#metaevent">MetaEvent</a></code></td>
          <td>Вызывается при движении курсора мыши над объектом допслоя.</td>
        </tr>
        <tr>
          <td><code><b>click</b></code></td>
          <td><code><a href="/doc/maps/ru/manual/base-classes#metaevent">MetaEvent</a></code></td>
          <td>Вызывается при клике мыши в допслой.</td>
        </tr>
        <tr>
          <td><code><b>dblclick</b></code></td>
          <td><code><a href="/doc/maps/ru/manual/base-classes#metaevent">MetaEvent</a></code></td>
          <td>Вызывается при двойном клике мыши в допслой.</td>
        </tr>
        <tr>
          <td><code><b>mousedown</b></code></td>
          <td><code><a href="/doc/maps/ru/manual/base-classes#metaevent">MetaEvent</a></code></td>
          <td>Вызывается при нажатии мыши, когда курсор находится над допслоем.</td>
        </tr>
        <tr>
          <td><code><b>contextmenu</b></code></td>
          <td><code><a href="/doc/maps/ru/manual/base-classes#metaevent">MetaEvent</a></code></td>
          <td>Вызывается при клике правой кнопкой мыши в допслой.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>getOrigin</b>()</code></td>
            <td><code>Object</code></td>
            <td>Возвращает origin-инстанс допслоя.</td>
        </tr>
    </tbody>
</table>

### DG.Meta.origin

Работает с метаданными слоя, наследует от <a href="/doc/maps/ru/manual/base-classes#dgclass"><code>DG.Class</code></a>.

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Использование</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Meta.origin</b>(
                <nobr>&lt;String&gt; <i>source</i>,</nobr>
                <nobr>&lt;DG.Meta.layer options&gt; <i>options?</i> )</nobr>
            </code></td>
            <td><code>DG.Meta.origin(&hellip;)</code></td>
            <td>Создает инстанс для работы с данными метаслоя. Принимает в качестве параметра source URL,
                по которому доступны тайлы допслоя.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>subdomains</b></code></td>
            <td><code>String</code> или <code>String[]</code></td>
            <td><code>'0123'</code></td>
            <td>Поддомены тайлового сервиса. Могут передаваться одной строкой (где каждая буква &mdash;
                имя поддомена) или массивом строк.</td>
        </tr>
        <tr>
            <td><code><b>dataFilter</b></code></td>
            <td><code>Function</code></td>
            <td><code>null</code></td>
            <td>Опциональный параметр, который принимает функцию для фильтрации или преобразования метаданных,
                полученных от сервера.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>getTileData</b>(
                <nobr>&lt;Object&gt; <i>coord</i>)</nobr>
            </code>
            <td><code>Object</code></td>
            <td>Возвращает метаданные метаслоя по заданному тайлу.</td>
        </tr>
        <tr>
            <td><code><b>setTileData</b>(
                <nobr>&lt;String&gt;/&lt;Object&gt; <i>coord</i>,</nobr>
                <nobr>&lt;Object&gt; <i>data</i>)</nobr>
            </code>
            <td><code>this</code></td>
            <td>Присваевает данные data для тайла с ключем coord.</td>
        </tr>
        <tr>
            <td><code><b>flush</b>()</code></td>
            <td><code>this</code></td>
            <td>Полностью очищает закешированные данные по всем тайлам.</td>
        </tr>
        <tr>
            <td><code><b>setURL</b>(
                <nobr>&lt;String&gt; <i>url</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>flush?</i>)</nobr>
            </code>
            <td><code>this</code></td>
            <td>Устанавливает url, по которому забираются метаданные. Если передан парметр flush=true,
                закешированные данные будут очищены.</td>
        </tr>
        <tr>
            <td><code><b>getTileKey</b>(
                <nobr>&lt;Object&gt; <i>coord</i>)</nobr>
            </code>
            <td><code>String</code></td>
            <td>Возвращает ключ тайла в виде строки.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/dg-migration.md
================================================
## Руководство по переходу на API 2.0

{toc}

### Описание

Раздел содержит примеры кода основных возможностей, которые помогут вам прейти с API карт
версии 1.0 на API карт версии 2.0.

### Подключение API

<table>
    <thead>
        <tr>
            <td><a href="/doc/maps/1.0/manual/map/#toc-load">Версия 1.0</a></td>
            <td><a href="/doc/maps/ru/manual/loading">Версия 2.0</a></td>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>
                <code>&lt;script src="https://maps.api.2gis.ru/1.0"&gt;&lt;/script&gt;

                    DG.autoload(function() {
                        // инициализация карты
                        ...
                    });</code>
            </td>
            <td>
                <code>&lt;script src="https://maps.api.2gis.ru/2.0/loader.js?pkg=full"&gt;&lt;/script&gt;
                
                DG.then(function() {
                    // инициализация карты
                    ...
                });</code>
            </td>
        </tr>
    </tbody>
</table>

### Инициализация карты

<table>
    <thead>
        <tr>
            <td><a href="/doc/maps/1.0/manual/map/#toc-init">Версия 1.0</a></td>
            <td><a href="/doc/maps/ru/manual/map#dgmap">Версия 2.0</a></td>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>
                <code>var map = new DG.Map('map');
                <nobr>var center = new DG.GeoPoint(82.89, 55.98);</nobr>
                map.setCenter(center, 13);</code>
            </td>
            <td>
                <code>var map = DG.map('map', {
                    <nobr>'center': [54.98, 82.89],</nobr>
                    'zoom': 13
                });</code>
            </td>
        </tr>
    </tbody>
</table>

### Отображение маркера

Добавление на карту маркера с картинкой по умолчанию:
<table>
    <thead>
        <tr>
            <td><a href="/doc/maps/1.0/manual/markers/#toc-base">Версия 1.0</a></td>
            <td><a href="/doc/maps/ru/manual/markers#dgmarker">Версия 2.0</a></td>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>
                <code><nobr>var position = new DG.GeoPoint(82.89, 54.98);</nobr>
                var marker = new DG.Markers.Common({
                    geoPoint: position
                });
                map.markers.add(marker);</code>
            </td>
            <td>
                <code><nobr>DG.marker([54.98, 82.89]).addTo(map);</nobr></code>
            </td>
        </tr>
    </tbody>
</table>

Добавление на карту маркера с адаптивной пользовательской картинкой:
<table>
    <thead>
        <tr>
            <td><a href="/doc/maps/1.0/manual/utils/#fun-getAdaptiveAcon">Версия 1.0</a></td>
            <td><a href="/doc/maps/ru/manual/markers#dgicon">Версия 2.0</a></td>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>
                <code><nobr>var position = new DG.GeoPoint(82.89, 54.98);</nobr>
                var desktopParams = [
                    'desktop-icon.png',
                    24, 24,
                    function() {
                        return new DG.Point(-12, -12)
                    }
                ];
                var mobileParams = [
                    '{density}-icon.png',
                    34, 34,
                    function() {
                        return new DG.Point(-17, -17)
                    }
                ];
                var myIcon = DG.Utils.getAdaptiveIcon({
                    desktop: desktopParams,
                    mobile:  mobileParams
                });
                var marker = new DG.Markers.Common({
                    geoPoint: position,
                    icon: myIcon
                });
                map.markers.add(marker);</code>
            </td>
            <td>
                <code>var myIcon = DG.icon({
                    iconUrl: 'my-icon.png',
                    <nobr>iconRetinaUrl: 'my-icon@2x.png',</nobr>
                    iconSize: [24, 24],
                    iconAnchor: [-12, -12]
                });
                DG.marker([54.98, 82.89], {
                    icon: myIcon
                }).addTo(map);</code>
            </td>
        </tr>
    </tbody>
</table>

### Отображение группы маркеров

<table>
    <thead>
        <tr>
            <td><a href="/doc/maps/1.0/manual/markers/#toc-dgmarkersgroup">Версия 1.0</a></td>
            <td><a href="/doc/maps/ru/manual/other-layers#dglayergroup">Версия 2.0</a></td></tr>
    </thead>
    <tbody>
        <tr>
            <td>
                <code><nobr>map.markers.createGroup('myGroup');</nobr>
                map.markers.add(marker1, 'myGroup');
                map.markers.add(marker2, 'myGroup');
                map.markers.add(marker3, 'myGroup');</code>
            </td>
            <td>
                <code><nobr>DG.layerGroup([marker1, marker2])</nobr>
                .addLayer(marker3).addTo(map);</code>
            </td>
        </tr>
    </tbody>
</table>

### Отображение маркера с привязанным попапом

<table>
    <thead>
        <tr>
            <td><a href="/doc/maps/1.0/manual/markers/#toc-dgmarkersballoon">Версия 1.0</a></td>
            <td><a href="/doc/maps/ru/manual/base-classes#layer-bindpopup">Версия 2.0</a></td>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>
                <code><nobr>var position = new DG.GeoPoint(82.89, 54.98);</nobr>
                var marker = new DG.Markers.MarkerWithBalloon({
                    geoPoint: position,
                    balloonOptions: {
                        contentHtml: 'Я бабочка!'
                    }
                });
                map.markers.add(marker);</code>
                            </td>
                            <td>
                <code>DG.marker([54.98, 82.89])
                <nobr>.addTo(map).bindPopup('Я бабочка!');</nobr></code>
            </td>
        </tr>
    </tbody>
</table>

### Отображение попапа

<table>
    <thead>
        <tr>
            <td><a href="/doc/maps/1.0/manual/balloons/#balloon-intro">Версия 1.0</a></td>
            <td><a href="/doc/maps/ru/manual/popup#dgpopup">Версия 2.0</a></td>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>
                <code><nobr>var position = new DG.GeoPoint(82.89, 54.98);</nobr>
                var myBalloon = new DG.Balloons.Common({
                    geoPoint: position,
                    contentHtml: 'Привет!'
                });
                map.balloons.add(myBalloon);</code>
            </td>
            <td>
                <code>DG.popup()
                .setLatLng([54.98, 82.89])
                .setContent('Привет!')
                .addTo(map);</code>
            </td>
        </tr>
    </tbody>
</table>

### Отображение элемента управления

Отображение пользовательского элемента управления в правом верхнем углу карты:
<table>
    <thead>
        <tr>
            <td><a href="/doc/maps/1.0/manual/controls/#toc-intro">Версия 1.0</a></td>
            <td><a href="/doc/maps/ru/manual/controls">Версия 2.0</a></td></tr>
    </thead>
    <tbody>
        <tr>
            <td>
                <code>var myControl = new MyControl();
                var positionOffset = new DG.Point(0, 0);
                var position = new DG.ControlPosition(DG.ControlPosition.TOP_RIGHT, positionOffset);
                map.controls.add(myControl, null, position);</code>
            </td>
            <td>
                <code><nobr>DG.control({ position: 'topright' })</nobr>
                .addTo(map)</code>
            </td>
        </tr>
    </tbody>
</table>


### Подписка на события

<table>
    <thead>
        <tr>
            <td><a href="/doc/maps/1.0/manual/events/#toc-intro">Версия 1.0</a></td>
            <td><a href="/doc/maps/ru/manual/base-classes#events">Версия 2.0</a></td>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>
                <code><nobr>var callback = function(e) {</nobr>
                    console.log(e.getPoint());
                };
                map.addEventListener(map.getContainerId(), 'DgClick', callback);</code>
            </td>
            <td>
                <code><nobr>map.on('click', function(e) {</nobr>
                    console.log(e.latlng);
                });</code>
            </td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/dg-project-detector.md
================================================
## Модуль определения проекта 2GIS

Проект — это агломерация, включающая крупный город и ближайшие населённые пункты.
Данный плагин позволяет получить информацию о просматриваемом в текущий момент времени проекте.

{toc}

### Примеры использования

Подписка на событие projectchange:

    map.on('projectchange', function (e) {
        console.log(e);
    });

Подписка на событие projectleave:

    map.on('projectleave', function (e) {
       console.log(e);
    });

### События

<table>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>projectchange</td>
            <td>ProjectEvent</td>
            <td>Возникает, когда пользователь переходит из одного проекта в другой.</td>
        </tr>
        <tr>
            <td>projectleave</td>
            <td>ProjectEvent</td>
            <td>Возникает, когда пользователь выходит за пределы текущего проекта.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>getProjectsList</td>
            <td>Object</td>
            <td>Возвращает все доступные проекты.</td>
        </tr>
        <tr>
            <td>getProject</td>
            <td>Object</td>
            <td>Возвращает текущий проект.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/dg-ruler.md
================================================
## Линейка

Отображает на карте линейку, позволяющую измерять расстояния между географическими точками.

{toc}

### DG.Ruler

#### Пример использования

Создание и отображение линейки на карте:

    var latLngs = [
        [51.7314, 36.1938],
        [51.7307, 36.1894],
        [51.7297, 36.1926],
        [51.7299, 36.1968],
        [51.7307, 36.1968]]
    DG.ruler(latLngs).addTo(map);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Использование</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Ruler</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>[]&gt; <i>latlngs</i>,</nobr>
                <nobr>&lt;<a href="#dgruler-options">Ruler options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td><code>DG.ruler(&hellip;)</code></td>
            <td>Создает объект линейки по переданному массиву географических точек и необязательному объекту опций.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table id='dgruler-options'>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>editable</b></code></td>
            <td><code>Boolean</code></td>
            <td><code><span class="string">'true'</span></td>
            <td>Возможно ли изменять промежуточные точки линейки.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>addTo</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/map#dgmap">Map</a>&gt; <i>map</i> )</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Добавляет линейку на карту.</td>
        </tr>
        <tr>
            <td><code><b>getTotalDistance</b>()</nobr></code></td>
            <td><code>Number</code></td>
            <td>Возвращает расстояние (в метрах) между начальной и конечной точками.</td>
        </tr>
        <tr>
            <td><code><b>addLatLng</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Добавляет точку в линейку.</td>
        </tr>
        <tr>
            <td><code><b>setLatLngs</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>[]&gt; <i>latlngs</i> )</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Заменяет все точки линейки массивом переданных географических точек.</td>
        </tr>
        <tr>
            <td><code><b>getLatLngs</b>()</code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>[]</code></td>
            <td>Возвращает массив точек линейки.</td>
        </tr>
        <tr>
            <td><code><b>spliceLatLngs</b>(
                <nobr>&lt;Number&gt; <i>index</i></nobr>,
                <nobr>&lt;Number&gt; <i>pointsToRemove</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng?</i>, &hellip; )</nobr>
            </code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>[]</code></td>
            <td>Позволяет добавлять, удалять или заменять точки в линейке. Синтаксис аналогичен
                <a target="_blank" href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice">Array#splice</a>.
                Возвращает массив удаленных точек.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/dg-traffic.md
================================================
## Информация о пробках

Создает слой с информацией о пробках. При наведении на участок дороги отображает дополнительную метаинформацию.

{toc}

### DG.Traffic

#### Конструктор

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Использование</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Traffic</b>(
                <nobr>&lt;<a href="#опции">DG.Traffic options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td><code>DG.Traffic(&hellip;)</code></td>
            <td>Создает слой пробок.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>disableLabel</b></code></td>
            <td><code>Boolean</code></td>
            <td><code><span class="string">false</span></td>
            <td>Если передать значение true, при наведении на участок дороги дополнительная информация
                отображаться не будет.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/dg-wkt.md
================================================
## Well-known text

Используется для получения векторных слоев API карт на основе их описания в
<a target="_blank" href="http://en.wikipedia.org/wiki/Well-known_text">WKT-формате</a>.

{toc}

### DG.Wkt

#### Пример использования

Считывает описание многоугольника в WKT-формате и отображает его на карте:

    var polygonComponents = 'POLYGON((82.91699 55.042136, 82.917522 55.040187, 82.918063 55.040235, 82.917540 55.042184,82.91699 55.042136))';
    DG.Wkt.geoJsonLayer(polygonComponents).addTo(map);

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>DG.Wkt.toGeoJSON</b>(
                <nobr>&lt;String&gt; <i>wkt</i>)</nobr>
            </code></td>
            <td><code>geoJSON</code></td>
            <td>Считывает строку в WKT-формате и проверяет ее корректность.
                Возвращает <a href="http://geojson.org/geojson-spec.html" target="_blank">GeoJSON</a>.</td>
        </tr>
        <tr>
            <td><code><b>DG.Wkt.toLatLngs</b>(
                <nobr>&lt;String | Array&gt; <i>wkt</i>)</nobr>
            </code></td>
            <td><code>Array</code></td>
            <td>Считывает строку в WKT-формате и возвращает массив точек в формате
                <a href="/doc/maps/ru/manual/basic-types/#dglatlng">LatLng</a> (ее внутреннее представление).
                Может принимать массив WKT строк.</td>
        </tr>
        <tr>
            <td><code><b>DG.Wkt.geoJsonLayer</b>(
                <nobr>&lt;String&gt; <i>wkt</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/ru/manual/other-layers#geojson-option">GeoJSON options</a>&gt; <i>options?</i>)</nobr></code></td>
            <td><code>Object</code></td>
            <td>Создает GeoJSON слой. Принимает строку в WKT-формате для отображения данных на карте и объект опций.
                Формирует векторный слой API карт на основе данных, считанных методом DG.Wkt.toGeoJSON. Этот метод
                поддерживает все опции конструктора класса <a href="/doc/maps/ru/manual/other-layers#dggeojson">DG.GeoJSON</a>.
                Например, можно передать параметр <code>DG.Wkt.geoJsonLayer(polygonComponents, {clickable:false})</code>,
                чтобы сделать слой некликабельным.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/dom-utils.md
================================================
## Работа с DOM

{toc}

### DG.DomEvent

Класс для работы с <a href="https://developer.mozilla.org/docs/Web/API/Event">событиями DOM</a>.

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="domevent-on">
            <td><code><b>on</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
                <nobr>&lt;String&gt; <i>types</i>,</nobr>
                <nobr>&lt;Function&gt; <i>fn</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

		    <td><code>this</code></td>
            <td>Добавляет метод <code>fn</code> к цепочкам обработчиков событий DOM, привязанных
                к элементу <code>el</code>. Вы также можете указать (изменить) контекст вызова
                обработчика (объект, на который ссылается ключевое слово <code>this</code> внутри
                обработчика). Также, можно указать несколько типов событий, разделив их пробелами
                (например: <code>&#39;click dblclick&#39;</code>).</td>
        </tr>
        <tr>
            <td><code><b>on</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
                <nobr>&lt;Object&gt; <i>eventMap</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет набор пар &#39;тип/обработчик&#39; в качестве обработчиков событий DOM
                (например:  <code>{click: onClick, mousemove: onMouseMove}</code>).</td>
        </tr>
        <tr id="domevent-off">
            <td><code><b>off</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
                <nobr>&lt;String&gt; <i>types</i>,</nobr>
                <nobr>&lt;Function&gt; <i>fn</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Удаляет метод <code>fn</code> из цепочек обработчиков событий DOM, привязанных
                к элементу <code>el</code>. Если метод не указан, то удаляются все методы,
                привязанные на текущий момент. Замечание: если методу <code>on</code> передавался
                контекстный объект, этот же объект должен быть передан и методу <code>off</code>.</td>
        </tr>
        <tr>
            <td><code><b>off</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
                <nobr>&lt;Object&gt; <i>eventMap</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Удаляет набор пар &#39;тип/обработчик&#39; из цепочек обработчиков событий DOM.</td>
        </tr>
        <tr id="domevent-stoppropagation">
            <td><code><b>stopPropagation</b>(
                <nobr>&lt;DOMEvent&gt; <i>ev</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Останавливает всплытие события к родительским элементам. Используется внутри
                функции-обработчика. Пример:
                <pre><code>DG.DomEvent.on(div, 'click', function (ev) {
    DG.DomEvent.stopPropagation(ev);
});</code></pre></td>
        </tr>
        <tr id="domevent-disablescrollpropagation">
            <td><code><b>disableScrollPropagation</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет <code>stopPropagation</code> к событиям элемента <code>&#39;mousewheel&#39;</code>.</td>
        </tr>
        <tr id="domevent-disableclickpropagation">
            <td><code><b>disableClickPropagation</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет <code>stopPropagation</code> к событиям элемента <code>&#39;click&#39;</code>,
                <code>&#39;doubleclick&#39;</code>, <code>&#39;mousedown&#39;</code> and
                <code>&#39;touchstart&#39;</code>.</td>
        </tr>
        <tr id="domevent-preventdefault">
            <td><code><b>preventDefault</b>(
                <nobr>&lt;DOMEvent&gt; <i>ev</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Предотвращает поведение DOM элемента по умолчанию (например, переход по ссылке указанной
                в свойстве <code>href</code> элемента <code>a</code>). Используется внутри функции-обработчика.</td>
        </tr>
        <tr id="domevent-stop">
            <td><code><b>stop</b>(
                <nobr>&lt;DOMEvent&gt; <i>ev</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Вызывает одновременно <code>stopPropagation</code> и <code>preventDefault</code>.
                Используется внутри функции-обработчика.</td>
        </tr>
        <tr id="domevent-getmouseposition">
            <td><code><b>getMousePosition</b>(
                <nobr>&lt;DOMEvent&gt; <i>ev</i>,</nobr>
                <nobr>&lt;HTMLElement&gt; <i>container?</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Возвращает нормализованную позицию мыши из события DOM относительно контейнера или
                относительно всей страницы, если контейнер не указан.</td>
        </tr>
        <tr id="domevent-getwheeldelta">
            <td><code><b>getWheelDelta</b>(
                <nobr>&lt;DOMEvent&gt; <i>ev</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Возвращает нормализованную дельту колесика мыши, в виде вертикального смещения
                в пикселях (отрицательного, при прокрутке вниз), из события DOM <code>mousewheel</code>.
                События от устройств, которые не поддерживают точную прокрутку, отображаются на пиксельные
                координаты так, чтобы дельта прокрутки попадала в диапазон 50-60 пикселей.</td>
        </tr>
        <tr id="domevent-addlistener">
            <td><code><b>addListener</b>(
                <nobr><i>…</i> )</nobr>
            </code></td>

		    <td><code>this</code></td>
            <td>Псевдоним для <a href="#domevent-on"><code>DG.DomEvent.on</code></a></td>
        </tr>
        <tr id="domevent-removelistener">
            <td><code><b>removeListener</b>(
                <nobr><i>…</i> )</nobr>
            </code></td>

		    <td><code>this</code></td>
            <td>Псевдоним для <a href="#domevent-off"><code>DG.DomEvent.off</code></a></td>
        </tr>
    </tbody>
</table>

### DG.DomUtil

Класс для работы с <a href="https://developer.mozilla.org/ru/docs/DOM/DOM_Reference">DOM деревом</a>.

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="domutil-get">
    		<td><code><b>get</b>(
    		    <nobr>&lt;String|HTMLElement&gt; <i>id</i> )</nobr>
    		</code></td>

		    <td><code>HTMLElement</code></td>
            <td>Возвращает элемент по его id, если параметром была передана строка, либо возвращает
                элемент непосредственно, если он был передан в качестве параметра.</td>
	    </tr>
        <tr id="domutil-getstyle">
    		<td><code><b>getStyle</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;String&gt; <i>styleAttrib</i> )</nobr>
		    </code></td>

		    <td><code>String</code></td>
            <td>Возвращает значение стилей элемента, установленных через атрибут sytle,
                включая вычисленные значения или значения, указанные с помощью CSS.</td>
    	</tr>
        <tr id="domutil-create">
		    <td><code><b>create</b>(
		        <nobr>&lt;String&gt; <i>tagName</i>,</nobr>
		        <nobr>&lt;String&gt; <i>className?</i>,</nobr>
		        <nobr>&lt;HTMLElement&gt; <i>container?</i> )</nobr>
		    </code></td>

		    <td><code>HTMLElement</code></td>
            <td>Создает HTML элемент <code>tagName</code>, устанавливает ему значение класса
                <code>className</code> и опционально добавляет его в элемент <code>container</code>.</td>
    	</tr>
        <tr id="domutil-remove">
		    <td><code><b>remove</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

		    <td><code></code></td>
		    <td>Удаляет элемент <code>el</code> из элемента контейнера.</td>
	    </tr>
        <tr id="domutil-empty">
		    <td><code><b>empty</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

    		<td><code></code></td>
		    <td>Удаляет все дочерние элементы из контейнера <code>el</code>.</td>
    	</tr>
        <tr id="domutil-tofront">
		    <td><code><b>toFront</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

    		<td><code></code></td>
    		<td>Перемещает элемент <code>el</code> в конец списка дочерних элементов, чтобы он
    		    отображался поверх остальных дочерних элементов контейнера.</td>
    	</tr>
        <tr id="domutil-toback">
		    <td><code><b>toBack</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

		    <td><code></code></td>
		    <td>Перемещает элемент <code>el</code> в начало списка дочерних элементов, чтобы он
		        отображался перед остальными дочерними элементами контейнера.</td>
	    </tr>
        <tr id="domutil-hasclass">
		    <td><code><b>hasClass</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;String&gt; <i>name</i> )</nobr>
		    </code></td>

		    <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если элемент содержит класс <code>name</code>.</td>
	    </tr>
        <tr id="domutil-addclass">
    		<td><code><b>addClass</b>(
    		    <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
    		    <nobr>&lt;String&gt; <i>name</i> )</nobr>
    		</code></td>

    		<td><code></code></td>
            <td>Добавляет класс <code>name</code> к элементу.</td>
    	</tr>
        <tr id="domutil-removeclass">
		    <td><code><b>removeClass</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;String&gt; <i>name</i> )</nobr>
		    </code></td>

		    <td><code></code></td>
            <td>Удаляет класс <code>name</code> из элемента.</td>
	    </tr>
        <tr id="domutil-setclass">
		    <td><code><b>setClass</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;String&gt; <i>name</i> )</nobr>
		    </code></td>

		    <td><code></code></td>
		    <td>Устанавливает класс у элемента.</td>
	    </tr>
        <tr id="domutil-getclass">
    		<td><code><b>getClass</b>(
    		    <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
    		</code></td>

    		<td><code>String</code></td>
    		<td>Возвращает значение класса элемента.</td>
    	</tr>
        <tr id="domutil-setopacity">
    		<td><code><b>setOpacity</b>(
    		    <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
    		    <nobr>&lt;Number&gt; <i>opacity</i> )</nobr>
    		</code></td>

    		<td><code></code></td>
    		<td>Устанавливает прозрачность элемента. Значение <code>opacity</code> должно быть
    		    в диапазоне от <code>0.0</code> до <code>1.0</code>.</td>
    	</tr>
        <tr id="domutil-testprop">
		    <td><code><b>testProp</b>(
		        <nobr>&lt;String[]&gt; <i>props</i> )</nobr>
		    </code></td>

		    <td><code>String|false</code></td>
		    <td>Перебирает массив наименований стилей элемента и возвращает первое корректное наименование.
		        Используется с префиксами производителей браузеров и стилями, вроде <code>transform</code>.</td>
	    </tr>
        <tr id="domutil-settransform">
		    <td><code><b>setTransform</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>offset</i>,</nobr>
		        <nobr>&lt;Number&gt; <i>scale?</i> )</nobr>
		    </code></td>

    		<td><code></code></td>
    		<td>Устанавливает стиль 3D CSS transform элемента <code>el</code> так, чтобы он был
    		    смещен на <code>offset</code> пикселей и увеличен/уменьшен в <code>scale</code> раз.
    		    Метод не работает, если браузер не поддерживает 3D CSS transforms.</td>
	    </tr>
        <tr id="domutil-setposition">
    		<td><code><b>setPosition</b>(
    		    <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
    		    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>position</i> )</nobr>
    		</code></td>

    		<td><code></code></td>
    		<td>Изменяет позиционирование элемента <code>el</code>, используя CSS translate или свойства
    		    top/left в зависимости от поддержки браузером.</td>
	    </tr>
        <tr id="domutil-getposition">
		    <td><code><b>getPosition</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

    		<td><code><a href="/doc/maps/ru/manual/#dgpoint">Point</a></code></td>
		    <td>Возвращает координаты элемента, ранее установленные методом <code>setPosition</code>.</td>
	    </tr>
        <tr id="domutil-disabletextselection">
    		<td><code><b>disableTextSelection</b>()</code></td>

    		<td><code></code></td>
    		<td>Отключает возможность возникновения <code>selectstart</code> событий DOM, обычно сопутствующих
    		    выделению текстового фрагмента на странице. Влияет на поведение всего документа.</td>
	    </tr>
        <tr id="domutil-enabletextselection">
		    <td><code><b>enableTextSelection</b>()</code></td>

		    <td><code></code></td>
		    <td>Включает возможность возникновения событий DOM <code>selectstart</code>, ранее отключенных
		        <a href="#domutil-disabletextselection"><code>DG.DomUtil.disableTextSelection</code></a>.</td>
	    </tr>
        <tr id="domutil-disableimagedrag">
		    <td><code><b>disableImageDrag</b>()</code></td>

    		<td><code></code></td>
    		<td>Отключает возможность возникновения <code>dragstart</code> событий DOM, обычно сопутствующих
    		    перемещению изображения по странице.</td>
	    </tr>
	    <tr id="domutil-enableimagedrag">
    		<td><code><b>enableImageDrag</b>()</code></td>

    		<td><code></code></td>
    		<td>Включает возможность возникновения событий DOM <code>dragstart</code>, ранее отключенных
    		    <a href="#domutil-disableimagedrag"><code>DG.DomUtil.disableImageDrag</code></a>.</td>
    	</tr>
        <tr id="domutil-preventoutline">
		    <td><code><b>preventOutline</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i> )</nobr>
		    </code></td>

    		<td><code></code></td>
    		<td>Делает <a href="https://developer.mozilla.org/ru/docs/Web/CSS/outline">outline</a>
    		    элемента <code>el</code> невидимой.</td>
    	</tr>
    	<tr id="domutil-restoreoutline">
	    	<td><code><b>restoreOutline</b>()</code></td>

    		<td><code></code></td>
    		<td>Отменяет эффект <a href="#domutil-preventoutline"><code>DG.DomUtil.preventOutline</code></a>.</td>
    	</tr>
    </tbody>
</table>

#### Свойства

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>TRANSFORM</b></code></td>
            <td><code>String</code></td>
            <td>Название CSS свойства transform с учетом префикса производителя браузера
                (например, <code>&#39;webkitTransform&#39;</code> для WebKit).</td>
        </tr>
        <tr>
            <td><code><b>TRANSITION</b></code></td>
            <td><code>String</code></td>
            <td>Название CSS свойства transition с учетом префикса производителя браузера</td>
        </tr>
    </tbody>
</table>

### DG.PosAnimation

Используется внутри библиотеки для анимаций перемещения, используя CSS3 transitions для современных
браузеров и таймер для IE6-9.

    var fx = new DG.PosAnimation();
    fx.run(el, [300, 500], 0.5);

#### События

<table>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="posanimation-start">
            <td><code><b>start</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/events#event">Event</a></code></td>
            <td>Вызывается во время старта анимации.</td>
        </tr>
        <tr id="posanimation-step">
            <td><code><b>step</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/events#event">Event</a></code></td>
            <td>Вызывается (периодически) в процессе анимации.</td>
        </tr>
        <tr id="posanimation-end">
            <td><code><b>end</b></code></td>
            <td><code><a href="/doc/maps/ru/ru/manual/events#event">Event</a></code></td>
            <td>Вызывается во время окончания анимации.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="posanimation-run">
		    <td><code><b>run</b>(
		        <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
		        <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>newPos</i>,</nobr>
		        <nobr>&lt;Number&gt; <i>duration?</i>,</nobr>
		        <nobr>&lt;Number&gt; <i>easeLinearity?</i>)</nobr>
		    </code></td>

		    <td><code></code></td>
            <td>Запускает анимацию перемещения элемента, полученного через аргумент метода.
                Дополнительно можно задать продолжительность анимации в секундах
                (по умолчанию <code>0.25</code>) и функцию затухания
                (третий аргумент <a target="_blank" href="http://cubic-bezier.com/#0,0,.5,1">кубической кривой Безье</a>,
                по умолчанию <code>0.5</code>).</td>
	    </tr>
	    <tr id="posanimation-stop">
		    <td><code><b>stop</b>()</code></td>
		    <td><code></code></td>
		    <td>Останавливает ранее запущенную анимацию.</td>
	    </tr>
    </tbody>
</table>

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->

### DG.Draggable

Класс, с помощью которого можно сделать DOM элемент перетаскиваемым (включая поддержку тач-устройств).
Работает только в том случае, если элемент был позиционирован с помошью <a href="#domutil-setposition">DG.DomUtil.setPosition</a>.

    var draggable = new DG.Draggable(elementToDrag);
    draggable.enable();

#### Свойства

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="draggable-clicktolerance">
		    <td><code><b>clickTolerance</b></code></td>
		    <td><code>Number</code></td>
		    <td><code>3</code></td>
		    <td>Максимальное количество пикселей, на которое может сдвинуться мышь при нажатой кнопке,
		        чтобы идентифицировать это событике как нажатие (а не начало перетаскивания).</td>
    	</tr>
    </tbody>
</table>

#### События

<table>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
    	<tr id="draggable-down">
    		<td><code><b>down</b></code></td>
    		<td><code><a href="/doc/maps/ru/manual/events#event">Event</a></code></td>
            <td>Вызывается перед началом перетаскивания.</td>
    	</tr>
    	<tr id="draggable-dragstart">
    		<td><code><b>dragstart</b></code></td>
    		<td><code><a href="/doc/maps/ru/manual/events#event">Event</a></code></td>
            <td>Вызывается в момент начала перетаскивания.</td>
    	</tr>
    	<tr id="draggable-predrag">
    		<td><code><b>predrag</b></code></td>
    		<td><code><a href="/doc/maps/ru/manual/events#event">Event</a></code></td>
            <td>Вызывается в процессе перетаскивания <i>перед</i> каждым обновлением позиции элемента.</td>
	    </tr>
	    <tr id="draggable-dragend">
    		<td><code><b>dragend</b></code></td>
    		<td><code><a href="/doc/maps/ru/manual/events#event">Event</a></code></td>
            <td>Вызывается в момент окончания перетаскивания.</td>
	    </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="draggable-enable">
            <td><code><b>enable</b>()</code></td>
            <td><code></code></td>
            <td>Включает возможность перетаскивания.</td>
        </tr>
        <tr id="draggable-disable">
            <td><code><b>disable</b>()</code></td>
            <td><code></code></td>
            <td>Отключает возможность перетаскивания.</td>
        </td>
    </tbody>
</table>

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/ru/manual/map.md
================================================
## Карта

В данном разделе описывается основной класс API карт, который используется для создания и управления картой на странице.

{toc}

### DG.Map

#### Пример использования

Инициализация карты в элементе <code>div</code> с id &quot;map&quot;, с указанием координат центра и коэффициента
масштабирования:

    var map = DG.map('map', {
        center: [54.98, 82.89],
        zoom: 13
    });

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-l-map">
            <td><code><b>DG.map</b>(
                <nobr>&lt;String&gt;> <i>id</i>,</nobr>
                <nobr>&lt;Map options&gt;> <i>options?</i> )</nobr>
            </code></td>
            <td>Инициализирует карту в DOM-узле <code>&lt;div&gt;</code> элемента с указанным id с необязательным
                набором опций, которые описаны ниже.</td>
        </tr>
        <tr>
            <td><code><b>DG.map</b>(
                <nobr>&lt;HTMLElement&gt; <i>el</i>,</nobr>
                <nobr>&lt;Map options&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Инициализирует карту в переданном DOM-узле <code>&lt;div&gt;</code> элемента с необязательным набором
                опций, которые описаны ниже.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-prefercanvas">
            <td><code><b>preferCanvas</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Должны ли экземпляры <a href="/doc/maps/ru/manual/vector-layers#dgpath"><code>Path</code></a>
                отрисовываться на <a href="/doc/maps/ru/manual/vector-layers#dgcanvas">
                <code>Canvas</code></a>. По умолчанию все экземпляры <code>Path</code>
                отрисовываются с помощью <a href="/doc/maps/ru/manual/vector-layers#dgsvg"><code>SVG</code></a> рендерера.
            </td>
        </tr>
        <tr id="map-protocol">
            <td><code><b>protocol</b></code></td>
            <td><code>String </code></td>
            <td><code>''</code></td>
            <td>Сетевой протокол, используемый в запросах к тайлам.
            </td>
        </tr>
    </tbody>
</table>

##### Опции элементов управления

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code><b>zoomControl</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code></td>
            <td>Добавлен ли <a href="/doc/maps/ru/manual/controls#dgcontrol.zoom">элемент управления масштабом</a>
                на карту.
            </td>
        </tr>
        <tr>
            <td><code><b>fullscreenControl</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code></td>
            <td>Добавлена ли <a href="/doc/maps/ru/manual/controls#dgcontrol.fullscreen">
                кнопка включения полноэкранного режима</a> на карту.
            </td>
        </tr>
    </tbody>
</table>

##### Опции взаимодействия

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr>
            <td><code><b>closePopupOnClick</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code></td>
            <td>Закрывать ли попапы при клике в карту.</td>
        </tr>
        <tr id="map-zoomsnap">
            <td><code><b>zoomSnap</b></code></td>
            <td><code>Number </code></td>
            <td><code>1</code></td>
            <td>Всегда приводит уровень масштабирования к значению кратному данному параметру. Приведение
                происходит сразу после выполнения <a href="#map-fitbounds"><code>fitBounds()</code></a>
                или изменения масштаба &quot;щипком&quot; (pinch-zoom). По умолчанию уровень масштабирования
                приводится к ближайшему целому числу; меньшие значения (например, <code>0.5</code> или
                <code>0.1</code>) позволяют более точно управлять приведением масшатаба. Значение <code>0</code>
                говорит о том, что уровень масштабирования не будет приводиться после <code>fitBounds</code>
                или изменения масштаба &quot;щипком&quot;.
            </td>
        </tr>
        <tr id="map-zoomdelta">
            <td><code><b>zoomDelta</b></code></td>
            <td><code>Number </code></td>
            <td><code>1</code></td>
            <td>Управляет тем, насколько изменится уровень масштаба после
                <a href="#map-zoomin"><code>zoomIn()</code></a>,
                <a href="#map-zoomout"><code>zoomOut()</code></a>, нажатия <code>+</code> или
                <code>-</code> на клавиатуре или используя
                <a href="/doc/maps/ru/manual/controls#dgcontrol.zoom">элемент управления масштабом</a>.
                Значения меньшие чем <code>1</code> (например, <code>0.5</code>) предоставляют большую точность.
            </td>
        </tr>
        <tr id="map-trackresize">
            <td><code><b>trackResize</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Обновляется ли карта при изменении размера окна браузера.</td>
        </tr>
        <tr id="map-boxzoom">
            <td><code><b>boxZoom</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Может ли масштаб карты быть изменен с помощью box-масштабирования (shift + выделение мышью).</td>
        </tr>
        <tr id="map-doubleclickzoom">
            <td><code><b>doubleClickZoom</b></code></td>
            <td><code>Boolean|String </code></td>
            <td><code>true</code></td>
            <td>Разрешено ли увеличивать масштаб карты двойным кликом мыши (удерживание Shift позволяет уменьшать
                масштаб). Если передано значение <code>center</code>, карта всегда масштабируется отностиельно центра
                просматриваемой области, независимо от положения курсора.
            </td>
        </tr>
        <tr id="map-dragging">
            <td><code><b>dragging</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Разрешено ли перетаскивать карту мышью или тачем.</td>
        </tr>
        <tr id="map-geoclicker">
            <td><code><b>geoclicker</b></code></td>
            <td><code>Boolean | Object</code></td>
            <td><code>false</code></td>
            <td>Включено ли геокодирование по клику (геокликер). Если <code>false</code>, тогда при клике в любой объект
                карты (улицы, дома, остановки) не будет отображаться информация об этом объекте. Если
                в качестве параметра передан объект с опциями, тогда геокликер будет включен. Опции
                <code>showPhotos</code> и <code>showBooklet</code> позволяют отключить в балуне организации ссылки на буклеты
                и фотографии.
            </td>
        </tr>
        <tr id="map-projectdetector">
            <td><code><b>projectDetector</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code></td>
            <td>Включает или отключает механизм определения проектов 2ГИС. Проект — это агломерация,
                включающая крупный город и ближайшие населённые пункты.
            </td>
        </tr>
        <tr id="map-tilescheck">
            <td><code><b>tilesCheck</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Возвращается ли карта к предыдущему состоянию, если на целевом уровне
                масштабирования нет тайлов.
            </td>
        </tr>
        <tr id="map-museum">
            <td><code><b>museum</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code></td>
            <td>Будет ли отображаться сообщение о том, что браузер не поддерживается.</td>
        </tr>
    </tbody>
</table>

##### Опции состояния карты

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-center">
            <td><code><b>center</b></code></td>
            <td><code>LatLng </code></td>
            <td><code>undefined</code></td>
            <td>Начальный географический центр карты.</td>
        </tr>
        <tr id="map-zoom">
            <td><code><b>zoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>undefined</code></td>
            <td>Начальный уровень масштаба.</td>
        </tr>
        <tr id="map-minzoom">
            <td><code><b>minZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>undefined</code></td>
            <td>Минимальный уровень масштабируемости карты. Переопределяет свойство <code>minZoom</code>
                используемых слоев.
            </td>
        </tr>
        <tr id="map-maxzoom">
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>undefined</code></td>
            <td>Максимальный уровень масштабируемости карты. Переопределяет свойство <code>maxZoom</code>
                используемых слоев.
            </td>
        </tr>
        <tr id="map-layers">
            <td><code><b>layers</b></code></td>
            <td><code>Layer[] </code></td>
            <td><code>[]</code></td>
            <td>Массив слоев, которые изначально будут добавлены на карту.</td>
        </tr>
        <tr id="map-maxbounds">
            <td><code><b>maxBounds</b></code></td>
            <td><code>LatLngBounds </code></td>
            <td><code>null</code></td>
            <td>Если свойство установлено, карта ограничивает область просмотра согласно заданным географическим
                границам, &quot;отбрасывая&quot; пользователя назад, если он пытается выйти за пределы установленных границ,
                а также не позволяет уменьшить масштаб так, чтобы можно было просмотреть неразрешенные участки
                карты. Для установки ограничения динамически, используйте метод
                <a href="#map-setmaxbounds">setMaxBounds</a>.
            </td>
        </tr>
        <tr id="map-renderer">
            <td><code><b>renderer</b></code></td>
            <td><code>Renderer </code></td>
            <td><code>*</code></td>
            <td>Метод, который используется для отрисовки векторных слоев на карте.
                По умолчанию устанавливается
                <a href="/doc/maps/ru/manual/vector-layers#dgsvg"><code>DG.SVG</code></a> или
                <a href="/doc/maps/ru/manual/vector-layers#dgcanvas"><code>DG.Canvas</code></a>
                в зависимости от поддержки браузером.
            </td>
        </tr>
        <tr id="map-poi">
            <td><code><b>poi</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Отображать ли точки интереса на карте.</td>
        </tr>
        <tr id="map-currentlang">
            <td><code><b>currentLang</b></code></td>
            <td><code>string</code></td>
            <td><code>''</code></td>
            <td>Язык пользовательского интерфейса карты (см. <a href="/doc/maps/ru/manual/dg-locale/">Локализация</a>)</td>
        </tr>
    </tbody>
</table>

##### Опции анимации

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-fadeanimation">
            <td><code><b>fadeAnimation</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Включена ли анимация затухания тайлов. По умолчанию включена во всех браузерах
                поддерживающих CSS3 transitions, кроме Android.
            </td>
        </tr>
        <tr id="map-markerzoomanimation">
            <td><code><b>markerZoomAnimation</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Включена ли анимация масштабирования маркеров при анимации масштабирования карты,
                если выключена, тогда маркеры пропадают во время анимации карты. По умолчанию включена
                во всех браузерах поддерживающих CSS3 transitions, кроме Android.
            </td>
        </tr>
        <tr id="map-transform3dlimit">
            <td><code><b>transform3DLimit</b></code></td>
            <td><code>Number </code></td>
            <td><code>2^23</code></td>
            <td>Определяет максимальное значение CSS translation transform. Значение по умолчанию
                изменять не стоит, до тех пор пока браузер не начинает позиционировать слои в
                неправильном месте после большего смещения в результате <code>panBy</code>.
            </td>
        </tr>
        <tr id="map-zoomanimation">
            <td><code><b>zoomAnimation</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Включена ли анимация масштабирования тайлов. По умолчанию включена во всех браузерах
                поддерживающих CSS3 transitions, кроме Android.
            </td>
        </tr>
        <tr id="map-zoomanimationthreshold">
            <td><code><b>zoomAnimationThreshold</b></code></td>
            <td><code>Number </code></td>
            <td><code>4</code></td>
            <td>Порог, начиная с которого будет отключаться анимация масштабирования.</td>
        </tr>
    </tbody>
</table>

##### Опции инерции при перемещении

<table>
    <thead>
	<tr>
        <th>Опция</th>
        <th>Тип</th>
        <th>По умолчанию</th>
        <th>Описание</th>
	</tr>
	</thead>
    <tbody>
        <tr id="map-inertia">
            <td><code><b>inertia</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>*</code></td>
            <td>
                Если опция включена, тогда создается эффект инерции при движении карты &mdash; при
                перетаскивании карта продолжает движение в том же направлении какое-то время. Полезно
                для тач-устройств. По умолчанию, эта опция включена везде, за исключением старых
                Android-устройств.
            </td>
        </tr>
        <tr id="map-inertiadeceleration">
            <td><code><b>inertiaDeceleration</b></code></td>
            <td><code>Number </code></td>
            <td><code>3000</code></td>
            <td>Величина, на которую замедляется движение карты, указывается в пикселях/секунду<sup>2</sup>.</td>
        </tr>
        <tr id="map-inertiamaxspeed">
            <td><code><b>inertiaMaxSpeed</b></code></td>
            <td><code>Number </code></td>
            <td><code>Infinity</code></td>
            <td>Максимальная скорость инерционного движения, указывается в пикселях/секунду.</td>
        </tr>
        <tr id="map-easelinearity">
            <td><code><b>easeLinearity</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.2</code></td>
            <td></td>
        </tr>
        <tr id="map-worldcopyjump">
            <td><code><b>worldCopyJump</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Опция позволяет зациклить просмотр карты с сохранением слоев и маркеров на ней.</td>
        </tr>
        <tr id="map-maxboundsviscosity">
            <td><code><b>maxBoundsViscosity</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.0</code></td>
            <td>Если установлено свойство <code>maxBounds</code>, эта опция позволяет контролировать
                &quot;прочность&quot; границ при перемещении карты мышью или тачем. Значение по умолчанию
                <code>0.0</code> &mdash; позволяет пользователю перемещать карту за ее границы с нормальной
                скоростью, чем выше значение, тем меньше будет скорость при пермещении за пределы границы карты.
                При значении <code>0.1</code>, границы становятся полностью &quot;непроницаемы&quot;, предотвращая любое
                перемещение карты вне их пределов.
            </td>
        </tr>
    </tbody>
</table>

##### Опции навигации клавишами

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-keyboard">
            <td><code><b>keyboard</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Устанавливает фокус на карту и позволяет перемещаться по карте с помощью
                кнопок <code>+</code>/<code>-</code> и стрелок клавиатуры.
            </td>
        </tr>
        <tr id="map-keyboardpandelta">
            <td><code><b>keyboardPanDelta</b></code></td>
            <td><code>Number </code></td>
            <td><code>80</code></td>
            <td>Указывает, на сколько пикселей сдвинется карта, при нажатии стрелки на клавиатуре.</td>
        </tr>
    </tbody>
</table>

##### Опции колеса мыши

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-scrollwheelzoom">
            <td><code><b>scrollWheelZoom</b></code></td>
            <td><code>Boolean | String </code></td>
            <td><code>true</code></td>
            <td>Можно ли изменять масштаб карты с помощью колеса мыши. Если в качестве параметра
                передано значение <code>&#39;center&#39;</code>, изменение масштаба будет происходить
                относительно центра просматриваемой области, вне зависимости от позиции указателя
                мыши.
            </td>
        </tr>
        <tr id="map-wheeldebouncetime">
            <td><code><b>wheelDebounceTime</b></code></td>
            <td><code>Number </code></td>
            <td><code>40</code></td>
            <td>Ограничевает частоту, с которой прокрутка колеса мыши будет отправлять событие на изменение
                масштаба (в милисекундах). По умолчанию, пользователь не может изменять масштаб карты
                более чем один раз в 40 мс.
            </td>
        </tr>
        <tr id="map-wheelpxperzoomlevel">
            <td><code><b>wheelPxPerZoomLevel</b></code></td>
            <td><code>Number </code></td>
            <td><code>50</code></td>
            <td>Какое количество пикселей прокрутки (можно определить через
                <a href="/doc/maps/ru/manual/dom-utils#domevent-getwheeldelta">DG.DomEvent.getWheelDelta</a>)
                означает изменение на один уровень масштабирования. Меньшие значения
                будут изменять масштаб карты, с помощью колеса, быстрей (и наоборот).
            </td>
        </tr>
    </tbody>
</table>

##### Опции взаимодействия на тач-устройствах

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-tap">
            <td><code><b>tap</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Активирует поддержку мгновенных тапов (отключение задержки в 200мс в iOS/Android)
                и долгих тапов (в этом случае посылается событие <code>contextmenu</code>).
            </td>
        </tr>
        <tr id="map-taptolerance">
            <td><code><b>tapTolerance</b></code></td>
            <td><code>Number </code></td>
            <td><code>15</code></td>
            <td>Максимальное число пикселей, на которое пользователь может сдвинуть свой палец во
                время тача, для того, чтобы это событие было воспринято как тап.
            </td>
        </tr>
        <tr id="map-touchzoom">
            <td><code><b>touchZoom</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>*</code></td>
            <td>Разрешено ли изменять масштаб карты двумя пальцами на тач-устройствах.
                Если передано значение <code>&#39;center&#39;</code>, карта всегда будет масштабироваться
                относительно центра просматриваемой области, независимо от того, где на карте произошли
                события тача. Активируется в веб-браузерах с тач поддержкой, за исключением устройств со
                старой версией Android.
            </td>
        </tr>
        <tr id="map-bounceatzoomlimits">
            <td><code><b>bounceAtZoomLimits</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code>, карта будет возвращаться к допустимому масштабу,
                когда пользователь будет пытаться выйти за предельный максимальный/минимальный
                масштаб карты с помощью масштабирования пальцами.
            </td>
        </tr>
    </tbody>
</table>

#### События

##### События слоев

<table>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-layeradd">
            <td><code><b>layeradd</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#layerevent">LayerEvent</a></code></td>
            <td>Вызывается при добавлении нового слоя на карту.</td>
        </tr>
        <tr id="map-layerremove">
            <td><code><b>layerremove</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#layerevent">LayerEvent</a></code></td>
            <td>Вызывается при удалении слоя с карты.</td>
        </tr>
    </tbody>
</table>

##### События изменения состояния карты

<table>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-zoomlevelschange">
            <td><code><b>zoomlevelschange</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается, если при добавлении или удалении слоя карты изменилось
                количество доступных уровней масштабирования.
            </td>
        </tr>
        <tr id="map-resize">
            <td><code><b>resize</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается при изменении размера карты.</td>
        </tr>
        <tr id="map-unload">
            <td><code><b>unload</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается при удалении карты c помощью метода <a href="#map-remove">remove</a>.</td>
        </tr>
        <tr id="map-viewreset">
            <td><code><b>viewreset</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается, когда нужно перерисовать содержимое карты (обычно при
                изменении масштаба или загрузке). Полезно при создании дополнительных слоев.
            </td>
        </tr>
        <tr id="map-load">
            <td><code><b>load</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается при инициализации карты (при первой установке ее центра и масштаба).</td>
        </tr>
        <tr id="map-zoomstart">
            <td><code><b>zoomstart</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается в начале изменения масштаба (перед анимацией изменения масштаба).</td>
        </tr>
        <tr id="map-movestart">
            <td><code><b>movestart</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается в начале изменения области просмотра карты (например, когда пользователь
                начинает перетаскивать карту).
            </td>
        </tr>
        <tr id="map-zoom">
            <td><code><b>zoom</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается периодически, в течении любого изменения уровня масштаба,
                включая анимации перелета.
            </td>
        </tr>
        <tr id="map-move">
            <td><code><b>move</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается периодически, во время любого передвижения карты, включая
                анимации перелета.
            </td>
        </tr>
        <tr id="map-zoomend">
            <td><code><b>zoomend</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается после изменения масштаба и анимаций.</td>
        </tr>
        <tr id="map-moveend">
            <td><code><b>moveend</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается при окончании передвижения карты (например, когда пользователь
                прекращает перетаскивать карту).
            </td>
        </tr>
        <tr id="map-projectchange">
            <td><code><b>projectchange</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#projectevent">ProjectEvent</a></code></td>
            <td>Вызывается при перемещении пользователя из одного
                <a href="#map-projectdetector">проекта 2ГИС</a> в другой.
            </td>
        </tr>
        <tr id="map-projectleave">
            <td><code><b>projectleave</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#projectevent">ProjectEvent</a></code></td>
            <td>Вызывается при выходе пользователя из текущего
                <a href="#map-projectdetector">проекта 2ГИС</a>.
            </td>
        </tr>
        <tr id="map-entranceshow">
            <td><code><b>entranceshow</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается при отображении входа в здание.</td>
        </tr>
        <tr id="map-entrancehide">
            <td><code><b>entrancehide</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается при скрытии входа в здание.</td>
        </tr>
        <tr id="map-poihover">
            <td><code><b>poihover</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#poievent">MetaEvent</a></code></td>
            <td>Вызывается при наведении курсора мыши на точку интереса.</td>
        </tr>
        <tr id="map-poileave">
            <td><code><b>poileave</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#poievent">MetaEvent</a></code></td>
            <td>Вызывается, когда курсор мыши покидает область точки интереса.</td>
        </tr>
        <tr id="map-langchange">
            <td><code><b>langchange</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#langevent">LangEvent</a></code></td>
            <td>Вызывается при изменении языка карты.</td>
        </tr>
    </tbody>
</table>

##### События попапа

<table>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-popupopen">
            <td><code><b>popupopen</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Вызывается при открытии попапа.</td>
        </tr>
        <tr id="map-popupclose">
            <td><code><b>popupclose</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Вызывается при закрытии попапа.</td>
        </tr>
        <tr id="map-autopanstart">
            <td><code><b>autopanstart</b></code></td>
            <td><code></code></td>
            <td>Вызывается, когда карта начинает двигаться после появления попапа.</td>
        </tr>
    </tbody>
</table>

##### События взаимодействий

<table>
    <thead>
        <tr>
            <th>События</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-click">
            <td><code><b>click</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Вызывается при клике (или тапе) по карте.</td>
        </tr>
        <tr id="map-dblclick">
            <td><code><b>dblclick</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Вызывается при двойном клике (или двойном тапе) по карте.</td>
        </tr>
        <tr id="map-mousedown">
            <td><code><b>mousedown</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Вызывается при нажатии кнопки мыши над областью карты.</td>
        </tr>
        <tr id="map-mouseup">
            <td><code><b>mouseup</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Вызывается, когда пользователь отпускает кнопку мыши над областью карты.</td>
        </tr>
        <tr id="map-mouseover">
            <td><code><b>mouseover</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Вызывается при наведении курсора мыши на карту.</td>
        </tr>
        <tr id="map-mouseout">
            <td><code><b>mouseout</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Вызывается, когда курсор мыши покидает область карты.</td>
        </tr>
        <tr id="map-mousemove">
            <td><code><b>mousemove</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Вызывается, когда курсор мыши перемещается над картой.</td>
        </tr>
        <tr id="map-contextmenu">
            <td><code><b>contextmenu</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Вызывается при нажатии правой кнопки мыши на карте, предотвращает появление
                стандартного контекстного меню браузера, если на это событие подписаны обработчики.
                Также вызывается на мобильных устройствах, когда пользователь удерживает тач
                в течение секунды (долгое нажатие).
            </td>
        </tr>
        <tr id="map-keypress">
            <td><code><b>keypress</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается при нажатии клавиш на клавиатуре, когда карта находится в фокусе.</td>
        </tr>
        <tr id="map-preclick">
            <td><code><b>preclick</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
            <td>Вызывается перед кликом мыши на карте (полезно, если нужно выполнить
                какое-либо действие до вызова обработчика клика).
            </td>
        </tr>
    </tbody>
</table>

##### События анимаций

<table>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-zoomanim">
            <td><code><b>zoomanim</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#zoomanimevent">ZoomAnimEvent</a></code></td>
            <td>Вызывается каждый кадр, в процессе изменения масштаба.</td>
        </tr>
    </tbody>
</table>

##### События местоположения

<table>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-locationerror">
            <td><code><b>locationerror</b></code></td>
            <td><code><a href="#errorevent">ErrorEvent</a></code></td>
            <td>Вызывается при возникновении ошибок, во время обнаружения местоположения пользователя
                (при использовании метода <a href="#map-locate"><code>locate</code></a>).
            </td>
        </tr>
        <tr id="map-locationfound">
            <td><code><b>locationfound</b></code></td>
            <td><code><a href="#locationevent">LocationEvent</a></code></td>
            <td>Вызывается при успешном обнаружении местоположения пользователя (при использовании метода
                <a href="#map-locate">locate</a>).
            </td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-getrenderer">
            <td>
                <code>
                    <b>getRenderer</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/vector-layers#dgpath">Path</a>&gt; <i>layer</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#dgrenderer">Renderer</a></code></td>
            <td>Возвращает экземпляр <a href="/doc/maps/ru/manual/base-classes#dgrenderer"><code>Renderer</code></a>,
                который должен быть использован для отрисовки необходимого
                <a href="/doc/maps/ru/manual/vector-layers#dgpath"><code>векторного слоя</code></a>. Метод гарантирует, что опции
                <a href="/doc/maps/ru/manual/base-classes#dgrenderer"><code>движка отображения</code></a> карты и векторных слоев
                будут учитываться, и что необходимые движки отображения действительно существуют на карте.
            </td>
        </tr>
    </tbody>
</table>

##### Методы слоев и элементов управления

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-addlayer">
            <td>
                <code>
                    <b>addLayer</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Добавляет слой на карту.</td>
        </tr>
        <tr id="map-removelayer">
            <td>
                <code>
                    <b>removeLayer</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Удаляет указанные слои с карты.</td>
        </tr>
        <tr id="map-haslayer">
            <td>
                <code>
                    <b>hasLayer</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i>)</nobr>
                </code>
            </td>
            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если слой, на данный момент, добавлен на карту.</td>
        </tr>
        <tr id="map-eachlayer">
            <td>
                <code>
                    <b>eachLayer</b>(
                    <nobr>&lt;Function&gt; <i>fn</i></nobr>,
                    <nobr>&lt;Object&gt; <i>context?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>
                Выполняет заданную функцию для каждого слоя карты. Дополнительно можно
                указать контекст выполнения функции.
<pre><code>map.eachLayer(function(layer){
    layer.bindPopup(&#39;Hello&#39;);
});
</code></pre>
            </td>
        </tr>
        <tr id="map-openpopup">
            <td>
                <code>
                    <b>openPopup</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/popup#dgpopup">Popup</a>&gt; <i>popup</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Показывает указанный попап, предварительно закрыв все открытые.</td>
        </tr>
        <tr id="map-openpopup">
            <td>
                <code>
                    <b>openPopup</b>(
                    <nobr>&lt;String|HTMLElement&gt; <i>content</i></nobr>,
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;<a href="/doc/maps/ru/manual/popup#popup-option">Popup options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Создает попап с переданными опциями и содержимым и открывает его в определенной точке на карте.</td>
        </tr>
        <tr id="map-closepopup">
            <td>
                <code>
                    <b>closePopup</b>(<nobr>&lt;<a href="/doc/maps/ru/manual/popup#dgpopup">Popup</a>&gt; <i>popup?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Закрывает попап, открытый с помощью <a href="/doc/maps/ru/manual/popup#map-openpopup">openPopup</a>.</td>
        </tr>
        <tr id="map-addcontrol">
            <td>
                <code>
                    <b>addControl</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/controls#dgcontrol">Control</a>&gt; <i>control</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Добавляет элемент управления на карту.</td>
        </tr>
        <tr id="map-removecontrol">
            <td>
                <code>
                    <b>removeControl</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/controls#dgcontrol">Control</a>&gt; <i>control</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Удаляет элемент управления с карты.</td>
        </tr>
    </tbody>
</table>

##### Методы модификации состояния карты

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-setview">
            <td>
                <code>
                    <b>setView</b>(
                    <nobr>&lt;LatLnt&gt; <i>center</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom</i></nobr>,
                    <nobr>&lt;Zoom/Pan options&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Устанавливает область просмотра карты (географический центр и масштаб).
                Дополнительно можно указать опции анимации.
            </td>
        </tr>
        <tr id="map-setzoom">
            <td>
                <code>
                    <b>setZoom</b>(
                    <nobr>&lt;Number&gt; <i>zoom</i></nobr>,
                    <nobr>&lt;Zoom/Pan options&gt; <i>options</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Устанавливает уровень масштаба.</td>
        </tr>
        <tr id="map-zoomin">
            <td>
                <code>
                    <b>zoomIn</b>(
                    <nobr>&lt;Number&gt; <i>delta?</i></nobr>,
                    <nobr>&lt;<a href="#опции-масштабирования">Zoom options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Увеличивает масштаб карты на величину <code>delta</code>
                (по умолчанию <a href="#map-zoomdelta"><code>zoomDelta</code></a>).
            </td>
        </tr>
        <tr id="map-zoomout">
            <td>
                <code>
                    <b>zoomOut</b>(
                    <nobr>&lt;Number&gt; <i>delta?</i></nobr>,
                    <nobr>&lt;<a href="#опции-масштабирования">Zoom options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Уменьшает масштаб карты на величину <code>delta</code>
                (по умолчанию <a href="#map-zoomdelta"><code>zoomDelta</code></a>).
            </td>
        </tr>
        <tr id="map-setzoomaround">
            <td>
                <code>
                    <b>setZoomAround</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom</i></nobr>,
                    <nobr>&lt;<a href="#опции-масштабирования">Zoom options</a>&gt; <i>options</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Масштабирует карту, сохраняя при этом указанную точку в неподвижном состоянии
                (например, используется для масштабировании при помощи колесика мыши и двойного клика).
            </td>
        </tr>
        <tr id="map-setzoomaround">
            <td>
                <code>
                    <b>setZoomAround</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>offset</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom</i></nobr>,
                    <nobr>&lt;<a href="#опции-масштабирования">Zoom options</a>&gt; <i>options</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Масштабирует карту, сохраняя при этом указанную точку в пикселях в неподвижном состоянии
                (относительно левого верхнего угла).
            </td>
        </tr>
        <tr id="map-fitbounds">
            <td>
                <code>
                    <b>fitBounds</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>bounds</i></nobr>,
                    <nobr>&lt;<a href="#опции-соответствия-границам">fitBounds options</a>&gt; <i>options</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Устанавливает область просмотра карты так, чтобы она содержала заданные границы,
                на максимально возможном уровне масштаба.
            </td>
        </tr>
        <tr id="map-fitworld">
            <td>
                <code>
                    <b>fitWorld</b>(
                    <nobr>&lt;<a href="#опции-соответствия-границам">fitBounds options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Устанавливает область просмотра карты так, чтобы та отображала весь мир,
                на максимально возможном уровне масштаба.
            </td>
        </tr>
        <tr id="map-panto">
            <td>
                <code>
                    <b>panTo</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;<a href="#опции-перемещения">Pan options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Передвигает карту к указанному центру.
            </td>
        </tr>
        <tr id="map-panby">
            <td>
                <code>
                    <b>panBy</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>offset</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Перемещает карту на заданное количество пикселей (анимировано).</td>
        </tr>
        <tr id="map-setmaxbounds">
            <td>
                <code>
                    <b>setMaxBounds</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgbounds">Bounds</a>&gt; <i>bounds</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Ограничивает область просмотра карты заданными границами (см. опцию
                <a href="#map-maxbounds">maxBounds</a>).
            </td>
        </tr>
        <tr id="map-setminzoom">
            <td><code><b>setMinZoom</b>(<nobr>&lt;Number&gt; <i>zoom</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Устанавливает нижний предел уровней масштабирования
                (см. опцию <a href="#map-minzoom">minZoom</a>).
            </td>
        </tr>
        <tr id="map-setmaxzoom">
            <td><code><b>setMaxZoom</b>(<nobr>&lt;Number&gt; <i>zoom</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Устанавливает верхний предел уровней масштабирования
                (см. опцию <a href="#map-minzoom">maxZoom</a>).
            </td>
        </tr>
        <tr id="map-paninsidebounds">
            <td>
                <code>
                    <b>panInsideBounds</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>bounds</i></nobr>,
                    <nobr>&lt;<a href="#опции-перемещения">Pan options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Перемещает карту в ближайшую область просмотра, лежащую в пределах заданных границ.
                Можно контролировать анимацию, передав объект опций вторым параметром.
            </td>
        </tr>
        <tr id="map-invalidatesize">
            <td><code><b>invalidateSize</b>(<nobr>&lt;Zoom/Pan options&gt; <i>options</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Обновляет карту при изменении размера ее контейнера. Этот метод необходимо вызывать,
                если размер контейнера изменяется динамически (по умолчанию, также будет происходить
                анимация переимещения). Если параметр <code>options.pan</code> установлен в <code>false</code>,
                то карта не будет перемещаться. Если параметр <code>options.debounceMoveend</code> установлен в
                <code>true</code>, то событие <code>moveend</code> не будет вызываться часто, даже
                если метод будет вызываться много раз подряд.
            </td>
        </tr>
        <tr id="map-invalidatesize">
            <td><code><b>invalidateSize</b>(<nobr>&lt;Boolean&gt; <i>animate</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Обновляет карту при изменении размера ее контейнера. Этот метод необходимо вызывать,
                если размер контейнера изменяется динамически (по умолчанию, также будет происходить
                анимация переимещения).
            </td>
        </tr>
        <tr id="map-stop">
            <td><code><b>stop</b>()</code></td>
            <td><code>this</code></td>
            <td>Останавливает текущие запущенные анимации <code>panTo</code> или <code>flyTo</code>.
            </td>
        </tr>
        <tr id="map-flyto">
            <td>
                <code>
                    <b>flyTo</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom?</i></nobr>,
                    <nobr>&lt;Zoom/Pan options&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Устанавливает область просмотра карты (гегорафический центр и масштаб), выполняя
                плавную анимацию изменения масштаба и перемещения.
            </td>
        </tr>
        <tr id="map-flytobounds">
            <td>
                <code>
                    <b>flyToBounds</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>bounds</i></nobr>,
                    <nobr>&lt;<a href="#опции-соответствия-границам">fitBounds options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Устанавливает область просмотра карты с плавной анимацией изменения масштаба и перемещения, как
                <a href="#map-flyto"><code>flyTo</code></a>, но примнимает в качестве параметра границы, как
                <a href="#map-fitbounds"><code>fitBounds</code></a>.
            </td>
        </tr>
        <tr id="map-setlang">
            <td><code><b>setLang</b>( <nobr>&lt;String&gt; <i>lang</i> )</nobr></code></td>
            <td><code>String</code></td>
            <td>Устанавливает <a href="/doc/maps/ru/manual/dg-locale">язык карты</a>. В качестве параметра
                принимает код языка (например, 'en').
            </td>
        </tr>
    </tbody>
</table>

##### Другие методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-addhandler">
            <td>
                <code>
                    <b>addHandler</b>(
                    <nobr>&lt;String&gt; <i>name</i></nobr>,
                    <nobr>&lt;Function&gt; <i>HandlerClass</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Добавляет новый <a href="/doc/maps/ru/manual/base-classes#dghandler"><code>Handler</code></a> на карту,
                c переданным именем и функцией-конструктором.
            </td>
        </tr>
        <tr id="map-remove">
            <td><code><b>remove</b>()</code></td>
            <td><code>this</code></td>
            <td>Удаляет карту и все обработчики, связанные с ней.</td>
        </td>
        </tr>
        <tr id="map-createpane">
            <td>
                <code>
                    <b>createPane</b>(
                    <nobr>&lt;String&gt; <i>name</i></nobr>,
                    <nobr>&lt;HTMLElement&gt; <i>container?</i>)</nobr>
                </code>
            </td>
            <td><code>HTMLElement</code></td>
            <td>Создает новую панель карты с данным именем, если она еще не существует, и затем
                возвращает ее. Панель создается как ребенок <code>container</code>,
                или как дочерний элемент главной панели карты, если <code>container</code> не установлен.
            </td>
        </tr>
        <tr id="map-getpane">
            <td><code><b>getPane</b>(<nobr>&lt;String | HTMLElement&gt; <i>pane</i>)</nobr></code></td>
            <td><code>HTMLElement</code></td>
            <td>Возвращает панель карты по ее имени или по ее HTML-элементу</td>
        </tr>
        <tr id="map-getpanes">
            <td><code><b>getPanes</b>()</code></td>
            <td><code>Object</code></td>
            <td>Возвращает объект, содержащий имена всех панелей как ключи и сами панели, как значения
            </td>
        </tr>
        <tr id="map-getcontainer">
            <td><code><b>getContainer</b>()</code></td>
            <td><code>HTMLElement</code></td>
            <td>Возвращает контейнер карты (HTML-элемент).</td>
        </tr>
        <tr id="map-whenready">
            <td>
                <code>
                    <b>whenReady</b>(
                    <nobr>&lt;Function&gt; <i>fn</i></nobr>,
                    <nobr>&lt;Object&gt; <i>context?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Выполняет функцию <code>fn</code> после инициализации карты (когда установлен
                центр и масштаб) и, по крайней мере, одним слоем, или сразу, если она
                была инициализирована ранее. Опционально можно передать контекст выполнения.
            </td>
        </tr>
    </tbody>
</table>

##### Методы получения состояния карты

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-getcenter">
            <td><code><b>getCenter</b>()</code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Возвращает географический центр области просмотра карты.</td>
        </tr>
        <tr id="map-getzoom">
            <td><code><b>getZoom</b>()</code></td>
            <td><code>Number</code></td>
            <td>Возвращает текущий уровень масштабирования.</td>
        </tr>
        <tr id="map-getbounds">
            <td><code><b>getBounds</b>()</code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlngbounds">LatLngBounds</a></code></td>
            <td>Возвращает географические прямоугольные границы текущей области просмотра карты.</td>
        </tr>
        <tr id="map-getminzoom">
            <td><code><b>getMinZoom</b>()</code></td>
            <td><code>Number</code></td>
            <td>Возвращает минимальный уровень масштабирования карты (если установлена опция
                <code>minZoom</code> у карты или любого слоя) или <code>0</code>, по умолчанию.
            </td>
        </tr>
        <tr id="map-getmaxzoom">
            <td><code><b>getMaxZoom</b>()</code></td>
            <td><code>Number</code></td>
            <td>Возвращает максимальный уровень масштабирования карты (если установлена опция
                <code>maxZoom</code> у карты или любого слоя).
            </td>
        </tr>
        <tr id="map-getboundszoom">
            <td>
                <code>
                    <b>getBoundsZoom</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>bounds</i></nobr>,
                    <nobr>&lt;Boolean&gt; <i>inside?</i>)</nobr>
                </code>
            </td>
            <td><code>Number</code></td>
            <td>Возвращает максимальный уровень масштабирования, при котором заданные границы полностью
                входят в область просмотра. Если опция <code>inside</code> установлена в <code>true</code>,
                тогда метод возвращает минимальный уровень зума, с теми же условиями.
            </td>
        </tr>
        <tr id="map-getsize">
            <td><code><b>getSize</b>()</code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Возвращает текущий размер контейнера карты (в пикселях).</td>
        </tr>
        <tr id="map-getpixelbounds">
            <td><code><b>getPixelBounds</b>()</code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgbounds">Bounds</a></code></td>
            <td>Возвращает прямоугольные границы области просмотра карты, спроецированные на пиксельные
                координаты (иногда полезно в реализациях слоев и оверлеев).
            </td>
        </tr>
        <tr id="map-getpixelorigin">
            <td><code><b>getPixelOrigin</b>()</code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Возвращает спроецированные пиксельные координаты левой верхней точки слоя карты.
                Полезно при реализации дополнительных слоев и оверлеев.
            </td>
        </tr>
        <tr id="map-getpixelworldbounds">
            <td>
                <code>
                    <b>getPixelWorldBounds</b>(
                    <nobr>&lt;Number&gt; <i>zoom?</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgbounds">Bounds</a></code></td>
            <td>Возвращает пиксельные координаты границ мира для заданного уровня масштабирования
                <code>zoom</code>. Если <code>zoom</code> пропущен, используется текущий уровень масштаба
                карты.
            </td>
        </tr>
        <tr id="map-getlang">
            <td><code><b>getLang</b>()</code></td>
            <td><code>String</code></td>
            <td>Возвращает текущий <a href="/doc/maps/ru/manual/dg-locale">язык карты</a>.</td>
        </tr>
    </tbody>
</table>

##### Методы преобразования

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-getzoomscale">
            <td>
                <code>
                    <b>getZoomScale</b>(
                    <nobr>&lt;Number&gt; <i>toZoom</i></nobr>,
                    <nobr>&lt;Number&gt; <i>fromZoom</i>)</nobr>
                </code>
            </td>
            <td><code>Number</code></td>
            <td>Возвращает коэффициент масштабирования, который будет применен к переходу с уровня
                <code>fromZoom</code> до <code>toZoom</code>. Используется внутри библиотеки в анимациях
                изменения масштаба.
            </td>
        </tr>
        <tr id="map-getscalezoom">
            <td>
                <code><b>getScaleZoom</b>(
                <nobr>&lt;Number&gt; <i>scale</i></nobr>,
                <nobr>&lt;Number&gt; <i>fromZoom</i>)</nobr>
                </code>
            </td>
            <td><code>Number</code></td>
            <td>Возвращает уровень масштаба, на котором окажется карта, если ее текущий уровень масштабирования
                <code>fromZoom</code> и коэффициент масштабирования <code>scale</code>. Метод обратный
                <a href="#map-getZoomScale"><code>getZoomScale</code></a>.
            </td>
        </tr>
        <tr id="map-project">
            <td>
                <code>
                    <b>project</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Проецирует географические координаты
                <a href="/doc/maps/ru/manual/basic-types#dglatlng"><code>LatLng</code></a>
                в соответствии с типом проекции карты (CRS), затем масштабирует их в соответствии с
                параметром zoom и CRS <a href="#transformation"><code>Transformation</code></a>
                Результат - пиксельные координаты относительно основания CRS.
            </td>
        </tr>
        <tr id="map-unproject">
            <td>
                <code>
                    <b>unproject</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i></nobr>,
                    <nobr>&lt;Number&gt; <i>zoom</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Метод обратный <a href="#map-project"><code>project</code></a>.
            </td>
        </tr>
        <tr id="map-layerpointtolatlng">
            <td>
                <code>
                    <b>layerPointToLatLng</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>По переданным пиксельным координатам относительно <a href="#map-getpixelorigin">origin pixel</a>
                возвращает соответствующие географические координаты (для текущего уровня масштабирования).
            </td>
        </tr>
        <tr id="map-latlngtolayerpoint">
            <td>
                <code>
                    <b>latLngToLayerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>По переданным географическим координатам возвращает соответствующие пиксельные
                координаты относительно <a href="#map-getpixelorigin">origin pixel</a>.
            </td>
        </tr>
        <tr id="map-wraplatlng">
            <td>
                <code>
                    <b>wrapLatLng</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Возвращает <a href="/doc/maps/ru/manual/basic-types#dglatlng"><code>LatLng</code></a>, где <code>lat</code>
                и <code>lng</code> &quot;зацикливаются&quot; в соответствии с CRS-свойствами <code>wrapLat</code> и
                <code>wrapLng</code>, если они выходят за  CRS-границы. По умолчанию
                это значит, что долгота переносится относительно линии перемены даты. Таким
                образом, ее значение всегда будет находиться между -180 и +180 градусами.
            </td>
        </tr>
        <tr id="map-distance">
            <td>
                <code>
                    <b>distance</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng1</i></nobr>,
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng2</i>)</nobr>
                </code>
            </td>
            <td><code>Number</code></td>
            <td>Возвращает расстояние между двумя географическими координатами в соответствии
                с CRS карты. По умолчанию расстояние измеряется в метрах.
            </td>
        </tr>
        <tr id="map-containerpointtolayerpoint">
            <td>
                <code>
                    <b>containerPointToLayerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>По переданным пиксельным координатам, относительно контейнера карты, возвращает
                соответствующие пиксельные координаты, относительно <a href="#map-getpixelorigin">origin pixel</a>.
            </td>
        </tr>
        <tr id="map-layerpointtocontainerpoint">
            <td>
                <code>
                    <b>layerPointToContainerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>По переданным пиксельным координатам, относительно <a href="#map-getpixelorigin">origin pixel</a>,
                возвращает соответствующие пиксельные координаты, относительно контейнера карты.
            </td>
        </tr>
        <tr id="map-containerpointtolatlng">
            <td>
                <code>
                    <b>containerPointToLatLng</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>point</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>По переданным пиксельным координатам, относительно контейнера карты,
                возвращает географические координаты (для текущего уровня масштабирования).
            </td>
        </tr>
        <tr id="map-latlngtocontainerpoint">
            <td>
                <code>
                    <b>latLngToContainerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>По переданным географическим координатам, возвращает пиксельные координаты,
                относительно контейнера карты.
            </td>
        </tr>
        <tr id="map-mouseeventtocontainerpoint">
            <td>
                <code>
                    <b>mouseEventToContainerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a>&gt; <i>ev</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>По переданному объекту MouseEvent, возвращает пиксельную координату места, где произошло событие,
                относительно левого верхнего угла контейнера карты.
            </td>
        </tr>
        <tr id="map-mouseeventtolayerpoint">
            <td>
                <code>
                    <b>mouseEventToLayerPoint</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a>&gt; <i>ev</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>По переданному объекту MouseEvent, возвращает пиксельную координату, где произошло
                событие, относительно <a href="#map-getpixelorigin">origin pixel</a>.
            </td>
        </tr>
        <tr id="map-mouseeventtolatlng">
            <td>
                <code>
                    <b>mouseEventToLatLng</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a>&gt; <i>ev</i>)</nobr>
                </code>
            </td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>По переданному объекту MouseEvent, возвращает географическую координату, где
                произошло событие.
            </td>
        </tr>
    </tbody>
</table>

##### Методы геолокации

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead
    ><tbody>
        <tr id="map-locate">
            <td>
                <code>
                    <b>locate</b>(
                    <nobr>&lt;<a href="#опции-определения-местоположения">Locate options</a>&gt; <i>options?</i>)</nobr>
                </code>
            </td>
            <td><code>this</code></td>
            <td>Пытается определить местоположение пользователя используя
                <a href="https://en.wikipedia.org/wiki/W3C_Geolocation_API" target="_blank">Geolocation API</a>.
                При успешном определении вызывается событие <code>locationfound</code> с данными о местоположении,
                в случае ошибки будет вызвано событие <code>locationerror</code>. Опционально устанавливает
                область просмотра карты согласно местоположению пользователя (или отображает карту
                мира, если возникла ошибка геолокации).
                Для дополнительной информации см.
                <a href="#Опции определения местоположения">опции определения местоположения</a>.
            </td>
        </tr>
        <tr id="map-stoplocate">
            <td><code><b>stopLocate</b>()</code></td>
            <td><code>this</code></td>
            <td>Останавливает отслеживание местоположения, предварительно инициированное методом
                <code>map.locate({watch: true})</code>, и предотвращает сброс карты, если map.locate
                был вызван с <code>({setView: true})</code>.
            </td>
        </tr>
    </tbody>
</table>

##### Методы, унаследованные от Evented

Методы, унаследованные от Evented, смотрите <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">здесь</a>.

#### Свойства

Свойства карты включают в себя обработчики взаимодействия, которые позволяют контролировать интерактивное поведение,
подключение и отключение определенных возможностей карты, таких как перетаскивание и масштабирование тачем
(см. методы <a href="/doc/maps/ru/manual/base-classes#dghandler">Handler</a>). Например:

    map.doubleClickZoom.disable();

Вы также можете получить доступ к элементам управления картой, которые включены по умолчанию, например,
к элементу управления масштабом:

    map.zoomControl.setPosition('topright');

##### Обработчики

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-boxzoom">
            <td><code><b>boxZoom</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Обработчик box-масштабирования (shift + выделение мышью).</td>
        </tr>
        <tr id="map-doubleclickzoom">
            <td><code><b>doubleClickZoom</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Обработчик масштабирования по двойному клику.</td>
        </tr>
        <tr id="map-dragging">
            <td><code><b>dragging</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Обработчик перетаскивания карты (мышью и тачем).</td>
        </tr>
        <tr id="map-keyboard">
            <td><code><b>keyboard</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Обработчик навигации с помощью клавиатуры.</td>
        </tr>
        <tr id="map-scrollwheelzoom">
            <td><code><b>scrollWheelZoom</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Обработчик масштабирования по скроллу.</td>
        </tr>
        <tr id="map-tap">
            <td><code><b>tap</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Обработчики мобильных тач хаков (быстрый тап и удерживание тача).</td>
        </tr>
        <tr id="map-touchzoom">
            <td><code><b>touchZoom</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#dghandler">Handler</a></code></td>
            <td>Обработчик масштабирования с помощью тача.</td>
        </tr>
        <tr id="map-geoclicker">
            <td><code><b>geoclicker</b></code></td>
            <td><a href="/doc/maps/ru/manual/base-classes#dghandler"><code>Handler</code></a></td>
            <td>Обработчик геокодирования по клику.</td>
        </tr>
        <tr id="map-projectDetector">
            <td><code><b>projectDetector</b></code></td>
            <td><a href="/doc/maps/ru/manual/base-classes#dghandler"><code>Handler</code></a></td>
            <td>Обработчик определения <a href="#map-projectdetector">проекта 2ГИС</a>.</td>
        </tr>
        <tr id="map-zoomcontrol">
            <td><code><b>zoomControl</b></code></td>
            <td><a href="/doc/maps/ru/manual/controls#dgcontrol.zoom"><code>Control.Zoom</code></a></td>
            <td>Элемент управления масштабом.</td>
        </tr>
        <tr id="map-fullscreenControl">
            <td><code><b>fullscreenControl</b></code></td>
            <td><a href="/doc/maps/ru/manual/controls#dgcontrol.fullscreen"><code>Control.FullScreen</code></a></td>
            <td>Кнопка включения полноэкранного режима.</td>
        </tr>
        <tr id="map-rulerControl">
            <td><code><b>rulerControl</b></code></td>
            <td><a href="/doc/maps/ru/manual/controls#dgcontrol.ruler"><code>Control.Ruler</code></a></td>
            <td>Кнопка включения линейки.</td>
        </tr>
        <tr id="map-trafficControl">
            <td><code><b>trafficControl</b></code></td>
            <td><a href="/doc/maps/ru/manual/controls#dgcontrol.traffic"><code>Control.Traffic</code></a></td>
            <td>Кнопка включения слоя с пробками.</td>
        </tr>
        <tr id="map-baseLayer">
            <td><code><b>baseLayer</b></code></td>
            <td><a href="/doc/maps/ru/manual/raster-layers#dgtilelayer"><code>TileLayer</code></a></td>
            <td>Слой с тайлами 2ГИС, автоматически добавляемый на карту при её создании.</td>
        </tr>
    </tbody>
</table>

#### Панели карты

Панели - это DOM-элементы, которые используются для контроля очередности отображения слоев на карте.
Получить панели можно с помощью методов <a href="#map-getpane"><code>map.getPane</code></a>
или <a href="#map-getpanes"><code>map.getPanes</code></a>. Новые панели можно создать
с помощью метода <a href="#map-createpane"><code>map.createPane</code></a>. У каждой карты
по умолчанию есть следующий набор панелей, которые отличаются только zIndex.

<table>
    <thead>
        <tr>
            <th>Панель</th>
            <th>Тип</th>
            <th>Z-index</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="map-mappane">
            <td><code><b>mapPane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>&#x27;auto&#x27;</code></td>
            <td>Панель, содержащая в себе все другие панели</td>
        </tr>
        <tr id="map-tilepane">
            <td><code><b>tilePane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>2</code></td>
            <td>Панель для тайловых слоев</td>
        </tr>
        <tr id="map-overlaypane">
            <td><code><b>overlayPane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>4</code></td>
            <td>Панель для векторных слоев, таких как ломаные и многоугольники.</td>
        </tr>
        <tr id="map-shadowpane">
            <td><code><b>shadowPane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>5</code></td>
            <td>Панель для наложения теней (например, тени от маркеров).</td>
        </tr>
        <tr id="map-markerpane">
            <td><code><b>markerPane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>6</code></td>
            <td>Панель маркеров.</td>
        </tr>
        <tr id="map-popuppane">
            <td><code><b>popupPane</b></code></td>
            <td><code>HTMLElement </code></td>
            <td><code>7</code></td>
            <td>Панель попапов.</td>
        </tr>
    </tbody>
</table>

#### Опции определения местоположения

Некоторые методы геолокации объекта <a href="#dgmap"><code>Map</code></a> принимают параметр
<code>options</code>. Это обычный JavaScript-объект со следующими опциональными компонентами:

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="locate-options-watch">
            <td><code><b>watch</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code>, то местоположение будет отслеживаться постоянно (вместо определения
                местоположения один раз) используя W3C метод <code>watchPosition</code>. Можно остановить
                отслеживание, вызвав метод <code><b>map.stopLocate</b>()</code>.</td>
            </td>
        </tr>
        <tr id="locate-options-setview">
            <td><code><b>setView</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code>, то автоматически устанавливает область просмотра карты в
                точку местоположения пользователя, в соответствии с точностью определения.
                В случае ошибки поиска, отображаетcя карта мира.
            </td>
        </tr>
        <tr id="locate-options-maxzoom">
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>Infinity</code></td>
            <td>Задает максимальный уровень масштабирования при автоматическом перемещения карты,
                когда включена опция <code>setView</code>.
            </td>
        </tr>
        <tr id="locate-options-timeout">
            <td><code><b>timeout</b></code></td>
            <td><code>Number </code></td>
            <td><code>10000</code></td>
            <td>Количество миллисекунд ожидания ответа геолокации, перед тем как произойдет вызов
                события <code>locationerror</code>.
            </td>
        </tr>
        <tr id="locate-options-maximumage">
            <td><code><b>maximumAge</b></code></td>
            <td><code>Number </code></td>
            <td><code>0</code></td>
            <td>Максимальное время жизни данных о местоположении. Если с момента последнего поиска
                прошло меньше времени, чем указанно в данной опции, <code>locate</code> вернет
                данные из кэша.
            </td>
        </tr>
        <tr id="locate-options-enablehighaccuracy">
            <td><code><b>enableHighAccuracy</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Включает функцию повышения точности, см.
                <a target="_blank" href="http://dev.w3.org/geo/api/spec-source.html#high-accuracy">
                описание в W3C спецификации</a>.
            </td>
        </tr>
    </tbody>
</table>


#### Опции масштабирования

Некоторые методы объекта <a href="#dgmap"><code>Map</code></a>, которые изменяют масштаб,
принимают параметр <code>options</code>. Это обычный JavaScript-объект со следующими
необязательными компонентами:

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="zoom-options-animate">
            <td><code><b>animate</b></code></td>
            <td><code>Boolean</code></td>
            <td><code></code></td>
            <td>Если не указано, то масштабирование будет анимироваться, если точка, относительно
                которой происходит масштабирование, находится в пределах просматриваемой области карты.
                Если <code>true</code>, всегда будет производиться попытка анимировать масштабирование,
                вне зависимости от положения источника масштабирования. Если <code>false</code>,
                то масштабирование будет происходить без анимации.
            </td>
        </tr>
    </tbody>
</table>

#### Опции перемещения

Некоторые методы объекта <a href="#dgmap"><code>Map</code></a>, которые меняют центр карты,
принимают параметр <code>options</code>. Это обычный JavaScript-объект со следующими
необязательными компонентами:

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="pan-options-animate">
            <td><code><b>animate</b></code></td>
            <td><code>Boolean</code></td>
            <td><code></code></td>
            <td>Если <code>true</code>, то перемещения будут анимироваться всегда. Если <code>false</code>,
                перемещения не будут анимироваться при сбросе карты в исходное положение, если она была
                передвинута более чем на один экран; перемещения также не будут анимироваться при установке
                нового смещения панели карты (за исключением использования метода <code>panBy</code>).
            </td>
        </tr>
        <tr id="pan-options-duration">
            <td><code><b>duration</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.25</code></td>
            <td>Продолжительность анимации перемещения.</td>
        </tr>
        <tr id="pan-options-easelinearity">
            <td><code><b>easeLinearity</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.25</code></td>
            <td>Коэффициент кривизны затухания анимации (третий параметр
                <a target="_blank" href="http://cubic-bezier.com/">Кривой Безье</a>). Значение 1.0 означает
                линейную анимацию; чем меньше значение, тем больше кривизна.
            </td>
        </tr>
        <tr id="pan-options-nomovestart">
            <td><code><b>noMoveStart</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code>, тогда при перемещении не будет инициироваться событие
                <code>movestart</code> (используется внутри библиотеки при реализации
                инерции перемещения).
            </td>
        </tr>
    </tbody>
</table>

#### Дополнительные опции масштабирования/перемещения

Дополнительные опции наследуются от <a href="#zoom-options">Zoom options</a> и
<a href="#pan-options">Pan options</a>

#### Опции соответствия границам

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
	<tr id="fitbounds-options-paddingtopleft">
		<td><code><b>paddingTopLeft</b></code></td>
		<td><code>Point </code></td>
		<td><code>[0, 0]</code></td>
        <td>Задает отступ от верхнего левого угла контейнера карты, который не должен учитываться
            при подстройке центра и масштаба. Удобно использовать, например, если на карте приложения
            имеется левая панель и вы не хотите, чтобы при масштабировании под ней скрывались объекты.
        </td>
        </tr>
        <tr id="fitbounds-options-paddingbottomright">
            <td><code><b>paddingBottomRight</b></code></td>
            <td><code>Point </code></td>
            <td><code>[0, 0]</code></td>
            <td>То же самое, но для нижнего правого угла карты.</td>
        </tr>
        <tr id="fitbounds-options-padding">
            <td><code><b>padding</b></code></td>
            <td><code>Point </code></td>
            <td><code>[0, 0]</code></td>
            <td>Эквивалентно установке и верхнего левого, и нижнего правого отступов в одинаковые значения.</td>
        </tr>
        <tr id="fitbounds-options-maxzoom">
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>null</code></td>
            <td>Максимальный возможный уровень зума.</td>
        </tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/markers.md
================================================
## Маркеры

{toc}

### DG.Marker

Маркер представляет собой маленькую картинку, которая связана с определенным местом на карте.

    DG.marker([54.98, 82.89]).addTo(map);

#### Создание

<table>
	<thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
		<tr>
			<td><code><b>DG.Marker</b>(
				<nobr>&lt;<a href="/doc/maps/ru/manual/base-types#dglatlng">LatLng</a>&gt; <i>latlng</i>,</nobr>
				<nobr>&lt;<a href="#опции">Marker options</a>&gt; <i>options?</i> )</nobr>
			</code></td>
			<td>Создает объект маркера с переданными географическими координатами и необязательными опциями.</td>
		</tr>
	</tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
			<th>Опция</th>
			<th>Тип</th>
			<th>По умолчанию</th>
			<th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-icon">
            <td><code><b>icon</b></code></td>
            <td><code><a href="#dgicon">Icon</a></code></td>
            <td><code>*</code></td>
			<td>Иконка, используемая для отображения маркера. Смотрите <a href="#dgicon">документацию по иконкам</a>,
			    для информации о настройке внешнего вида маркеров. Новые маркеры по умолчанию принимают стиль
			    <code>DG.Icon.Default()</code>.</td>
        </tr>
        <tr id="marker-interactive">
            <td><code><b>interactive</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
			<td>Если значение <code>false</code>, тогда обработчик клика по маркеру не вызывается.
                Маркер ведет себя как часть нижележащего слоя карты.</td>
        </tr>
        <tr id="marker-draggable">
            <td><code><b>draggable</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
			<td>Можно ли перетаскивать маркер или нет.</td>
        </tr>
        <tr id="marker-keyboard">
            <td><code><b>keyboard</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Можно ли переходить к маркеру по нажатию на кнопку <code>Tab</code> и имитировать клик при
                нажатиии <code>Enter</code>.</td>
        </tr>
        <tr id="marker-title">
            <td><code><b>title</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
			<td>Текст подсказки при наведении курсора на маркер (по умолчанию не отображается).</td>
        </tr>
        <tr id="marker-alt">
            <td><code><b>alt</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
			<td>Текст для <code>alt</code> атрибута иконки (полезно для accessibility).</td>
        </tr>
        <tr id="marker-zindexoffset">
            <td><code><b>zIndexOffset</b></code></td>
            <td><code>Number </code></td>
            <td><code>0</code></td>
			<td>По умолчанию, свойство z-index изображения маркера устанавливается автоматически, в зависимости
                от его географического положения (широты). Используйте эту опцию, если необходимо разместить
                маркер поверх (или под) другим элементом, указав большее, например <code>1000</code>,
                (или меньшее) значение.</td>
        </tr>
        <tr id="marker-opacity">
            <td><code><b>opacity</b></code></td>
            <td><code>Number </code></td>
            <td><code>1.0</code></td>
			<td>Прозрачность маркера.</td>
        </tr>
        <tr id="marker-riseonhover">
            <td><code><b>riseOnHover</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
			<td>Если значение <code>true</code>, тогда маркер отобразится поверх остальных при наведении
                на него мышью.</td>
        </tr>
        <tr id="marker-riseoffset">
            <td><code><b>riseOffset</b></code></td>
            <td><code>Number </code></td>
            <td><code>250</code></td>
			<td>Позволяет задать шаг z-index при использовании <code>riseOnHover</code>.</td>
        </tr>
        <tr id="marker-pane">
            <td><code><b>pane</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;markerPane&#x27;</code></td>
            <td>Панель карты, на которую будет добавлен маркер.</td>
        </tr>
    </tbody>
</table>

#### События

<table>
    <thead>
        <tr>
			<th>Событие</th>
			<th>Данные</th>
			<th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-click">
            <td><code><b>click</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
			<td>Вызывается при клике (или тапу) по маркеру.</td>
        </tr>
        <tr id="marker-dblclick">
            <td><code><b>dblclick</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
			<td>Вызывается при двойном клике (или двойному тапу) по маркеру.</td>
        </tr>
        <tr id="marker-mousedown">
            <td><code><b>mousedown</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
			<td>Вызывается при нажатии кнопки мыши над маркером.</td>
        </tr>
        <tr id="marker-mouseover">
            <td><code><b>mouseover</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
			<td>Вызывается при наведении курсора мыши на маркер.</td>
        </tr>
        <tr id="marker-mouseout">
            <td><code><b>mouseout</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
			<td>Вызывается, когда курсор мыши покидает область маркера.</td>
        </tr>
        <tr id="marker-contextmenu">
            <td><code><b>contextmenu</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#mouseevent">MouseEvent</a></code></td>
			<td>Вызывается при нажатии правой кнопки мыши над маркером.</td>
        </tr>
        <tr id="marker-move">
            <td><code><b>move</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается, когда маркер перемещается с помощью метода
                <a href="#marker-setlatlng"><code>setLatLng</code></a> или обычным
                <a href="#marker-dragging">перетаскиванием</a>. Старые и новые координаты попадают в
                аргументы события как <code>oldLatLng</code> и <a href="/doc/maps/ru/manual/basic-types#dglatlng"><code>latlng</code></a>.</td>
        </tr>
    </tbody>
</table>

##### События перетаскивания

<table>
    <thead>
        <tr>
			<th>Событие</th>
			<th>Данные</th>
			<th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-dragstart">
            <td><code><b>dragstart</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
			<td>Вызывается, когда пользователь начинает перетаскивать маркер.</td>
        </tr>
        <tr id="marker-movestart">
            <td><code><b>movestart</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
			<td>Вызывается, когда маркер фактически начинает перемещаться во время перетаскивания.</td>
        </tr>
        <tr id="marker-drag">
            <td><code><b>drag</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
			<td>Вызывается периодически, во время перетаскивания маркера.</td>
        </tr>
        <tr id="marker-dragend">
            <td><code><b>dragend</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#dragendevent">DragEndEvent</a></code></td>
			<td>Вызывается, когда пользователь прекращает перетаскивание маркера.</td>
        </tr>
        <tr id="marker-moveend">
            <td><code><b>moveend</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
			<td>Вызывается, когда маркер фактически прекращает перемещаться во время перетаскивания.</td>
        </tr>
    </tbody>
</table>

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

<table>
    <thead>
        <tr>
			<th>Событие</th>
			<th>Данные</th>
			<th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-add">
            <td><code><b>add</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается, когда слой (маркер) добавляется на карту</td>
        </tr>
        <tr id="marker-remove">
            <td><code><b>remove</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается, когда слой (маркер) удаляется с карты</td>
        </tr>
    </tbody>
</table>

События попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

<table>
    <thead>
        <tr>
			<th>Событие</th>
			<th>Данные</th>
			<th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-popupopen">
            <td><code><b>popupopen</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Вызывается, когда открывается попап, привязанный к данному слою (маркеру).</td>
        </tr>
        <tr id="marker-popupclose">
            <td><code><b>popupclose</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Вызывается, когда закрываетс попап, привязанный к данному слою (маркеру).</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-getlatlng">
            <td><code><b>getLatLng</b>()</nobr></code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Возвращает текущую географическую позицию маркера.</td>
        </tr>
        <tr id="marker-setlatlng">
            <td><code><b>setLatLng</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr>
                </code></td>
            <td><code>this</code></td>
            <td>Устанавилвает позицию маркера по переданным географическим координатам.</td>
        </tr>
        <tr id="marker-setzindexoffset">
            <td><code><b>setZIndexOffset</b>(
                    <nobr>&lt;Number&gt; <i>offset</i>)</nobr>
                </code></td>
            <td><code>this</code></td>
            <td>Изменяет <a href="#marker-zindexoffset">смещение zIndex</a> маркера.</td>
        </tr>
        <tr id="marker-seticon">
            <td><code><b>setIcon</b>(
                    <nobr>&lt;<a href="#dgicon">Icon</a>&gt; <i>icon</i>)</nobr>
                </code></td>
            <td><code>this</code></td>
            <td>Устанавливает иконку маркера</td>
        </tr>
        <tr id="marker-setopacity">
            <td><code><b>setOpacity</b>(
                    <nobr>&lt;Number&gt; <i>opacity</i>)</nobr>
                </code></td>
            <td><code>this</code></td>
            <td>Изменяет уровень прозрачности маркера. </td>
        </tr>
	    <tr id="marker-bindlabel">
	        <td><code><b>bindLabel</b>(&lt;String&gt; content, &lt;<a href="/doc/maps/ru/manual/dg-label#опции">Label options</a>&gt; options?)</code></td>
            <td><code>this</code></td>
            <td>Добавляет всплывающую подсказку для маркера или обновляет содержимое уже созданной.</td>
	    </tr>
	    <tr id="marker-unbindlabel">
	        <td><code><b>unbindLabel</b>()</code></td>
	        <td><code>this</code></td>
            <td>Отвязывает всплывающую подсказку от маркера.</td>
	    </tr>
	    <tr id="marker-showLabel">
	        <td><code><b>showLabel</b>()</code></td>
	        <td><code>this</code></td>
            <td>Показывает всплывающую подсказку (в случае использования опции
            <code><a href="/doc/maps/ru/manual/dg-label#label-static">static</a></code>).</td>
	    </tr>
	    <tr id="marker-hideLabel">
	        <td><code><b>hideLabel</b>()</code></td>
	        <td><code>this</code></td>
            <td>Скрывает всплывающую подсказку (в случае использования опции <code>static</code>).</td>
	    </tr>
    </tbody>
</table>

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

#### Обработчики взаимодействия

Свойства маркера включают в себя обработчики взаимодействия, которые позволяют контролировать
интерактивное поведение маркера, а также подключение и отключение определенных возможностей,
таких как перетаскивание (см. методы Handler). Например:

    marker.dragging.disable();

<table>
    <thead>
        <tr>
			<th>Свойство</th>
			<th>Тип</th>
			<th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="marker-dragging">
            <td><code><b>dragging</b></code></td>
            <td><code><a href="/doc/maps/manual/base-classes#dghandler">Handler</a></code></td>
			<td>Обработчик перетаскивания маркера (мышью и тачем).</td>
        </tr>
    </tbody>
</table>

### DG.Icon

Иконка, которую можно использовать при создании маркера. Например:

    var myIcon = DG.icon({
        iconUrl: 'my-icon.png',
        iconRetinaUrl: 'my-icon@2x.png',
        iconSize: [38, 95],
        iconAnchor: [22, 94],
        popupAnchor: [-3, -76],
        shadowUrl: 'my-icon-shadow.png',
        shadowRetinaUrl: 'my-icon-shadow@2x.png',
        shadowSize: [68, 95],
        shadowAnchor: [22, 94]
    });

    DG.marker([50.505, 30.57], {icon: myIcon}).addTo(map);

#### Создание

<table>
	<thead>
	    <tr>
            <th>Конструктор</th>
            <th>Описание</th>
	    </tr>
	</thead>
	<tbody>
	    <tr>
            <td><code><b>DG.icon</b>(
                <nobr>&lt;<a href="#icon-option">Icon options</a>&gt; <i>options</i>)</nobr>
            </code></td>
	        <td>Создает объект иконки, на основании переданных опций.</td>
	    </tr>
	</tbody>
</table>

#### Опции

<table id="dgicon-options">
    <thead>
        <tr>
			<th>Опция</th>
			<th>Тип</th>
			<th>По умолчанию</th>
			<th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="icon-iconurl">
            <td><code><b>iconUrl</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
	        <td>Обязательный URL к изображению иконки (абсолютный или относительный).</td>
        </tr>
        <tr id="icon-iconretinaurl">
            <td><code><b>iconRetinaUrl</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
	        <td>URL к изображению иконки для устройств с Retina экраном (абсолютный или относительный).</td>
        </tr>
        <tr id="icon-iconsize">
            <td><code><b>iconSize</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-types#dgpoint">Point</a></code></td>
            <td><code>null</code></td>
	        <td>Размер изображения иконки в пикселях.</td>
        </tr>
        <tr id="icon-iconanchor">
            <td><code><b>iconAnchor</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-types#dgpoint">Point</a></code></td>
            <td><code>null</code></td>
	        <td>Координаты "ножки" иконки (относительно ее левого верхнего угла).
	            Иконка будет установлена так, чтобы эта точка соответствовала географическому положению маркера.
                По умолчанию "ножка" располагается по центру иконки; дополнительно положение может быть настроено
                через отрицательные значения CSS-свойства margin.</td>
        </tr>
        <tr id="icon-popupanchor">
            <td><code><b>popupAnchor</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
	        <td>Координаты точки, из которой будет открываться попап (относительно <code>iconAnchor</code>).</td>
        </tr>
        <tr id="icon-shadowurl">
            <td><code><b>shadowUrl</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
	        <td>URL к изображению тени иконки. Если не указан, тогда тени не будет.</td>
        </tr>
        <tr id="icon-shadowretinaurl">
            <td><code><b>shadowRetinaUrl</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
	        <td>URL к изображению тени иконки для устройств с Retina экраном.
                Если не указан, тогда тени не будет.</td>
        </tr>
        <tr id="icon-shadowsize">
            <td><code><b>shadowSize</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
	        <td>Размер изображения тени в пикселях.</td>
        </tr>
        <tr id="icon-shadowanchor">
            <td><code><b>shadowAnchor</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
	        <td>Координаты "ножки" тени (относительно ее левого верхнего угла).
                Значение по умолчанию такое же, как у <code>iconAnchor</code>.</td>
        </tr>
        <tr id="icon-classname">
            <td><code><b>className</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
	        <td>Значение класса, которое будет присвоено изображениям иконки и тени. По умолчанию пустое.</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

<table id="dgicon-methods">
    <thead>
        <tr>
			<th>Метод</th>
			<th>Возвращает</th>
			<th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="icon-createicon">
            <td><code><b>createIcon</b>(<nobr>&lt;HTMLElement&gt; <i>oldIcon?</i>)</nobr></code></td>
            <td><code>HTMLElement</code></td>
            <td>Вызывается внутри библиотеки, когда должна быть показана иконка, возвращает
                HTML-элемент <code>&lt;img&gt;</code> со стилями, соответсвующими переданным опциям.</td>
        </tr>
        <tr id="icon-createshadow">
            <td><code><b>createShadow</b>(<nobr>&lt;HTMLElement&gt; <i>oldIcon?</i>)</nobr></code></td>
            <td><code>HTMLElement</code></td>
            <td>Тоже что и <code>createIcon</code>, но с тенью за иконкой.</td>
        </tr>
    </tbody>
</table>

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.DivIcon

Иконка для маркеров, которые используют простой элемент <code>&lt;div&gt;</code> вместо изображения.
Наследуется от <a href="#dgicon"><code>Icon</code></a>, но игнорирует опции теней и <code>iconUrl</code>.

    // вы можете установить стиль класса .my-div-icon в CSS
    var myIcon = DG.divIcon({className: 'my-div-icon'});

    DG.marker([50.505, 30.57], {icon: myIcon}).addTo(map);

#### Создание

<table>
	<thead>
	    <tr>
	        <th>Конструктор</th>
	        <th>Описание</th>
	    </tr>
	</thead>
	<tbody>
	    <tr>
	        <td><code><b>DG.DivIcon</b>(
	            <nobr>&lt;<a href="#divicon-options">DivIcon options</a>&gt; <i>options</i> )</nobr>
	        </code></td>
	        <td>Создает объект <code>DG.DivIcon</code>, на основании переданных опций.</td>
	    </tr>
	</tbody>
</table>

#### Опции

<table>
	<thead>
	    <tr>
			<th>Опция</th>
			<th>Тип</th>
			<th>По умолчанию</th>
			<th>Описание</th>
	    </tr>
	</thead>
	<tbody>
        <tr id="divicon-html">
            <td><code><b>html</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
	        <td>HTML код, который будет установлен как содержимое иконки. По умолчанию пустой.</td>
        </tr>
        <tr id="divicon-bgpos">
            <td><code><b>bgPos</b></code></td>
            <td><code>Point </code></td>
            <td><code>[0, 0]</code></td>
            <td>Опциональное относительное позиционирование фона в пикселях</td>
        </tr>
	</tbody>
</table>

Опции, унаследованные от <a href="#dgicon-options">Icon</a> <!-- TODO: include options -->

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

Методы, унаследованные от <a href="#dgicon-methods">Icon</a> <!-- TODO: include methods -->

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/ru/manual/other-layers.md
================================================
## Дополнительные слои

{toc}

### DG.LayerGroup

Используется для группировки нескольких слоев, чтобы обрабатывать их как один. При добавлении
группового слоя на карту, все другие слои, добавляемые и удаляемые из группы, также будут
добавлены или удалены с карты. Расширяет <a href="/doc/maps/ru/manual/base-classes#dglayer"><code>DG.Layer</code></a>.

    DG.layerGroup([marker1, marker2])
        .addLayer(polyline)
        .addTo(map);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="layergroup-l-layergroup">
            <td><code><b>DG.layerGroup</b>(
                <nobr>&lt;Layer[]&gt; <i>layers</i> )</nobr>
            </code></td>
            <td>Создает объект группы, принимает начальный набор слоев для группировки (опционально).</td>
        </tr>
    </tbody>
</table>

#### Опции

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a> <!-- TODO: include events -->

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="layergroup-togeojson">
            <td><code><b>toGeoJSON</b>()</code></td>

            <td><code>Object</code></td>
            <td>Возвращает <a href="http://en.wikipedia.org/wiki/GeoJSON">
                <code>GeoJSON</code></a> объект, описывающий группу слоев, как <code>GeometryCollection</code>.</td>
        </tr>
        <tr id="layergroup-addlayer">
            <td><code><b>addLayer</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Добавляет указанный слой в группу.</td>
        </tr>
        <tr id="layergroup-removelayer">
            <td><code><b>removeLayer</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Удаляет указанный слой из группы.</td>
        </tr>
        <tr>
            <td><code><b>removeLayer</b>(
                <nobr>&lt;Number&gt; <i>id</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Удаляет из группы слой, с указанным ID.</td>
        </tr>
        <tr id="layergroup-haslayer">
            <td><code><b>hasLayer</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i> )</nobr>
            </code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если указанный слой уже добавлен в группу.</td>
        </tr>
        <tr id="layergroup-clearlayers">
            <td><code><b>clearLayers</b>()</code></td>

            <td><code>this</code></td>
            <td>Удаляет все слои из группы.</td>
        </tr>
        <tr id="layergroup-invoke">
            <td><code><b>invoke</b>(
                <nobr>&lt;string&gt; <i>methodName</i>, <i>…</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Вызывает метод <code>methodName</code> у каждого слоя из группы. Возможна передача
                дополнительных параметров. Пропускает слои, у которых не реализован <code>methodName</code>.</td>
        </tr>
        <tr id="layergroup-eachlayer">
            <td><code><b>eachLayer</b>(
                <nobr>&lt;Function&gt; <i>fn</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Итерационно обходит все слои группы. Возможна передача контекстного объекта в функцию итератор.
                <code class="lang-js">group.eachLayer(function (layer) {
                    layer.bindPopup(&#39;Hello&#39;);
                });</code></td>
        </tr>
        <tr id="layergroup-getlayer">
            <td><code><b>getLayer</b>(
                <nobr>&lt;Number&gt; <i>id</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a></code></td>
            <td>Возвращает слой с указанным ID.</td>
        </tr>
        <tr id="layergroup-getlayers">
            <td><code><b>getLayers</b>()</code></td>

            <td><code>Layer[]</code></td>
            <td>Возвращает массив всех слоев группы.</td>
        </tr>
        <tr id="layergroup-setzindex">
            <td><code><b>setZIndex</b>(
                <nobr>&lt;Number&gt; <i>zIndex</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Вызывает метод <code>setZIndex</code> у каждого слоя из группы, передавая аргумент z-index.</td>
        </tr>
        <tr id="layergroup-getlayerid">
            <td><code><b>getLayerId</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a>&gt; <i>layer</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Возвращает ID для указанного слоя.</td>
        </tr>
    </tbody>
</table>

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->

### DG.FeatureGroup

Расширяет <a href="#dglayergroup"><code>DG.LayerGroup</code></a>, добавляя обработку событий мыши
(получаемых от членов группы) и общий метод bindPopup.

    DG.featureGroup([marker1, marker2, polyline])
        .bindPopup('Привет, Мир!')
        .on('click', function() { alert('Вы щелкнули по группе!'); })
        .addTo(map);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
	<tbody>
        <tr id="featuregroup-l-featuregroup">
            <td><code><b>DG.featureGroup</b>(
                <nobr>&lt;Layer[]&gt; <i>layers</i> )</nobr>
            </code></td>
            <td>Создает объект группы, принимает начальный набор слоев для группировки (опционально).</td>
        </tr>
    </tbody>
</table>

#### Опции

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a> <!-- TODO: include events -->

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="featuregroup-setstyle">
            <td><code><b>setStyle</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/vector-layers#dgpath-options">Path options</a>&gt; <i>style</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Устанавливает указанные опции векторного объекта для каждого слоя из группы, у которого реализован
                метод <code>setStyle</code>.</td>
        </tr>
        <tr id="featuregroup-bringtofront">
            <td><code><b>bringToFront</b>()</code></td>

            <td><code>this</code></td>
            <td>Позиционирует слой группы поверх остальных слоев.</td>
        </tr>
        <tr id="featuregroup-bringtoback">
            <td><code><b>bringToBack</b>()</code></td>

            <td><code>this</code></td>
            <td>Позиционирует слой группы под остальными слоями.</td>
        </tr>
        <tr id="featuregroup-getbounds">
            <td><code><b>getBounds</b>()</code></td>

            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlngbounds">LatLngBounds</a></code></td>
            <td>Возвращает прямоугольные границы LatLngBounds объекта Feature Group (для корректной работы метода
                слои в группе должны возвращать подобную информацию о себе).</td>
        </tr>
    </tbody>
</table>

Методы, унаследованные от <a href="#dglayergroup">LayerGroup</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->

### DG.GeoJSON

Описывает объект GeoJSON или массив объектов GeoJSON. Позволяет корректно интерпретировать данные
GeoJSON и отобразить их на карте. Расширяет <a href="#dgfeaturegroup"><code>DG.FeatureGroup</code></a>.

    DG.geoJson(data, {
        style: function (feature) {
            return {color: feature.properties.color};
        }
    }).bindPopup(function (layer) {
        return layer.feature.properties.description;
    }).addTo(map);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
	<tbody>
        <tr id="geojson-l-geojson">
            <td><code><b>DG.geoJSON</b>(
                <nobr>&lt;Object&gt; <i>geojson?</i>,</nobr>
                <nobr>&lt;<a href="#geojson-option">GeoJSON options</a>&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Создает слой GeoJSON. Опционально принимает объект в формате
                <a href="http://geojson.org/geojson-spec.html">GeoJSON</a> (возможна передача этого объекта позже,
                 используя метод <code>addData</code>) и объект с <code>опциями</code>.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table id="geojson-option">
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
	<tbody>
        <tr id="geojson-pointtolayer">
            <td><code><b>pointToLayer</b></code></td>
            <td><code>Function </code></td>
            <td><code>*</code></td>
            <td><code>Функция</code>, определяющая, как точки GeoJSON будут создавать слои API карт.
                API карт вызывает метод, если он реализован, передавая объекты точек GeoJSON и
                <a href="/doc/maps/ru/manual/basic-types#dglatlng"><code>LatLng</code></a>.
                По умолчанию, будут создаваться обычные <a href="/doc/maps/ru/manual/markers#dgmarker"><code>Маркеры</code></a>:
                <code class="lang-js">function(geoJsonPoint, latlng) {
                    return DG.marker(latlng);
                }
                </code></td>
        </tr>
        <tr id="geojson-style">
            <td><code><b>style</b></code></td>
            <td><code>Function </code></td>
            <td><code>*</code></td>
            <td><code>Функция</code>, определяющая
                <a href="/doc/maps/ru/manual/vector-layers#dgpath-options"><code>Path options</code></a>
                для стилизации отображения GeoJSON линий и полигонов. API карт вызывает метод, если он реализован,
                при каждом добавлении данных. По умолчанию, стили никак не изменяются:
                <code class="lang-js">function (geoJsonFeature) {
                    return {}
                }
                </code></td>
        </tr>
        <tr id="geojson-oneachfeature">
            <td><code><b>onEachFeature</b></code></td>
            <td><code>Function </code></td>
            <td><code>*</code></td>
            <td><code>Функция</code>, которая будет вызвана после каждого создания и стилизации нового
                <a href="/doc/maps/ru/manual/base-classes#dglayer"><code>слоя</code></a>.
                Удобно использовать для подключения обработчиков событий и попапов.
                По умолчанию, никаких дополнительных действий не происходит:
                <code class="lang-js">function (layer) {}
                </code></td>
        </tr>
        <tr id="geojson-filter">
            <td><code><b>filter</b></code></td>
            <td><code>Function </code></td>
            <td><code>*</code></td>
            <td><code>Функция</code>, которая определяет, должен ли отображаться указанный объект или нет.
                По умолчанию, отображаются все объекты:
                <code class="lang-js">function (geoJsonFeature) {
                    return true;
                }
                </code></td>
        </tr>
        <tr id="geojson-coordstolatlng">
            <td><code><b>coordsToLatLng</b></code></td>
            <td><code>Function </code></td>
            <td><code>*</code></td>
            <td><code>Функция</code>, которая будет использоваться для преобразования координат GeoJSON
                в координаты <a href="/doc/maps/ru/manual/basic-types#dglatlng"><code>LatLng</code></a>s.
                По умолчанию будет использован статический метод <code>coordsToLatLng</code>.</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a> <!-- TODO: include events -->

#### Методы

Методы, унаследованные от <a href="#dgfeaturegroup">FeatureGroup</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="#dglayergroup">LayerGroup</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->

#### Статические функции

Есть несколько статических функций, которые можно использовать без создания экземпляров класса DG.GeoJSON:

<table>
    <thead>
        <tr>
            <th>Функция</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
	<tbody>
        <tr id="geojson-geometrytolayer">
            <td><code><b>geometryToLayer</b>(
                <nobr>&lt;Object&gt; <i>featureData</i>,</nobr>
                <nobr>&lt;<a href="#geojson-option">GeoJSON options</a>&gt; <i>options?</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a></code></td>
            <td>Создает <a href="/doc/maps/ru/manual/base-classes#dglayer"><code>Слой</code></a> на основе переданного
                GeoJSON объекта. Может использовать собственные функции <a href="#geojson-pointtolayer"><code>pointToLayer</code></a>
                и/или <a href="#geojson-coordstolatlng"><code>coordsToLatLng</code></a>, если они переданы в объекте опций.</td>
        </tr>
        <tr id="geojson-coordstolatlng">
            <td><code><b>coordsToLatLng</b>(
                <nobr>&lt;Array&gt; <i>coords</i> )</nobr>
            </code></td>

            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Создает объект <a href="/doc/maps/ru/manual/basic-types#dglatlng"><code>LatLng</code></a> из массива
                двух чисел, переданных в формате (longitude, latitude), или трех чисел, в формате (longitude, latitude, altitude),
                которые используются в GeoJSON для представления точек.</td>
        </tr>
        <tr>
            <td><code><b>coordsToLatLngs</b>(
                <nobr>&lt;Array&gt; <i>coords</i>,</nobr>
                <nobr>&lt;Number&gt; <i>levelsDeep?</i>,</nobr>
                <nobr>&lt;Function&gt; <i>coordsToLatLng?</i> )</nobr>
            </code></td>

            <td><code>Array</code></td>
            <td>Создает многомерный массив объектов <a href="/doc/maps/ru/manual/basic-types#dglatlng"><code>LatLng</code></a>
                из массива GeoJSON координат. <code>levelsDeep</code> определяет уровень вложенности (0 для массива точек,
                1 для массива массивов точек, и т.д., по умолчанию 0). Может использовать собственную функцию
                <a href="#geojson-coordstolatlng"><code>coordsToLatLng</code></a> для преобразования.</td>
        </tr>
        <tr id="geojson-latlngtocoords">
            <td><code><b>latLngToCoords</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i> )</nobr>
            </code></td>

            <td><code>Array</code></td>
            <td>Обратная операция для <a href="#geojson-coordstolatlng"><code>coordsToLatLng</code></a></td>
        </tr>
        <tr id="geojson-latlngstocoords">
            <td><code><b>latLngsToCoords</b>(
                <nobr>&lt;Array&gt; <i>latlngs</i>,</nobr>
                <nobr>&lt;Number&gt; <i>levelsDeep?</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>closed?</i> )</nobr>
            </code></td>

            <td><code>Array</code></td>
            <td>Обратная операция для <a href="#geojson-coordstolatlngs"><code>coordsToLatLngs</code></a>
                Опция <code>closed</code> определяет, нужно ли добавлять первую точку в конец массива и используется
                только в случае, если <code>levelsDeep</code> равен 0.</td>
        </tr>
        <tr id="geojson-asfeature">
            <td><code><b>asFeature</b>(
                <nobr>&lt;Object&gt; <i>geojson</i> )</nobr>
            </code></td>

            <td><code>Object</code></td>
            <td>Нормализует геометрические примитивы GeoJSON в объекты GeoJSON.</td>
        </tr>
    </tbody>
</table>

### DG.GridLayer

Универсальный класс для обработки тайловой сетки из HTML элементов. Это базовый класс, от которого наследуются
все тайловые слои. Поддерживает создание, анимацию и другие действия с элементами, представляющими тайл, такими
как <code>&lt;canvas&gt;</code>, <code>&lt;img&gt;</code> или <code>&lt;div&gt;</code>.

#### Использование в синхронном коде

Для того, чтобы создать собственный слой, нужно произвести наследование от GridLayer и реализовать метод
<code>create()</code>, которому будет передан объект <a href="/doc/maps/ru/manual/basic-types#dgpoint"><code>Point</code></a>
с <code>x</code>, <code>y</code> и <code>z</code> (уровень увеличения) координатами для отображения тайла.

    var CanvasLayer = DG.GridLayer.extend({
        createTile: function(coords){
            // создаем элемент <canvas>
            var tile = DG.DomUtil.create('canvas', 'leaflet-tile');
            // устанавливаем размер тайла
            var size = this.getTileSize();
            tile.width = size.x;
            tile.height = size.y;
            // получаем объект контекста и рисуем что-нибудь на нем, используя coords.x, coords.y и coords.z
            var ctx = canvas.getContext('2d');
            // возвращаем получившийся объект, чтобы его можно было отобразить на экране
            return tile;
        }
    });

#### Использование в асинхронном коде

Создавать объекты тайлов можно и асинхронно. Когда объект тайла полностью создан, его можно вернуть в API карт,
используя функцию обратного вызова done().

    var CanvasLayer = DG.GridLayer.extend({
        createTile: function(coords, done){
            var error;
            // создаем элемент <canvas>
            var tile = DG.DomUtil.create('canvas', 'leaflet-tile');
            // устанавливаем размер тайла
            var size = this.getTileSize();
            tile.width = size.x;
            tile.height = size.y;
            // рисуем что-нибудь и возвращаем итоговый тайл, используя функцию обратного вызова done()
            done(error, tile);
        }
    });

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
	<tbody>
        <tr id="gridlayer-l-gridlayer">
            <td><code><b>DG.gridLayer</b>(
                <nobr>&lt;GridLayer options&gt; <i>options?</i> )</nobr>
            </code></td>
            <td>Создает новый объект GridLayer.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table id='gridlayer-options'>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>Значение<br>по умолчанию</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="gridlayer-tilesize">
            <td><code><b>tileSize</b></code></td>
            <td><code>Number|Point </code></td>
            <td><code>256</code></td>
            <td>Ширина и высота тайлов. Используйте число, если ширина и высота одинаковые,
                или объект <code>DG.point(ширина, высота)</code> в противном случае.</td>
        </tr>
        <tr id="gridlayer-opacity">
            <td><code><b>opacity</b></code></td>
            <td><code>Number </code></td>
            <td><code>1.0</code></td>
            <td>Уровень полупрозрачности тайлов. Может использоваться в функции <code>createTile()</code>.</td>
        </tr>
        <tr id="gridlayer-updatewhenidle">
            <td><code><b>updateWhenIdle</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>depends</code></td>
            <td>Если значение <code>false</code>, новые тайлы подгружаются в процессе перемещения карты, в противном случае,
                только после окончания перемещения карты по экрану (можно использовать для лучшей производительности).
                <code>true</code> по умолчанию на мобильных устройствах, и <code>false</code> в остальных случаях.</td>
        </tr>
        <tr id="gridlayer-updateinterval">
            <td><code><b>updateInterval</b></code></td>
            <td><code>Number </code></td>
            <td><code>200</code></td>
            <td>Тайлы не будут обновляться чаще, чем раз в <code>updateInterval</code> миллисекунд.</td>
        </tr>
        <tr id="gridlayer-attribution">
            <td><code><b>attribution</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
            <td>Информация, которая будет отображаться в строке об авторстве, например &quot;© 2GIS&quot;.</td>
        </tr>
        <tr id="gridlayer-zindex">
            <td><code><b>zIndex</b></code></td>
            <td><code>Number </code></td>
            <td><code>1</code></td>
            <td>zIndex для тайлового слоя.</td>
        </tr>
        <tr id="gridlayer-bounds">
            <td><code><b>bounds</b></code></td>
            <td><code>LatLngBounds </code></td>
            <td><code>undefined</code></td>
            <td>Если задан, тайлы будут загружаться только для указанного региона, заданного
                <a href="/doc/maps/ru/manual/basic-types#dglatlngbounds"><code>LatLngBounds</code></a>.</td>
        </tr>
        <tr id="gridlayer-minzoom">
            <td><code><b>minZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>0</code></td>
            <td>Минимальный уровень масштабирования, при котором будут загружаться тайлы. По умолчанию - вся карта.</td>
        </tr>
        <tr id="gridlayer-maxzoom">
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>undefined</code></td>
            <td>Максимальный уровень масштабирования, при котором будут загружаться тайлы. По умолчанию не задан.</td>
        </tr>
        <tr id="gridlayer-nowrap">
            <td><code><b>noWrap</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Будет ли зацикливаться отображение слоя при малом масштабе. Если параметр <code>true</code>, слой
                будет отображен только один раз.</td>
        </tr>
        <tr id="gridlayer-pane">
            <td><code><b>pane</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;tilePane&#x27;</code></td>
            <td><code>Панель карты</code>, на которую будет добавлен слой.</td>
        </tr>
    </tbody>
</table>

#### События

<table id='gridlayer-events'>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="gridlayer-loading">
            <td><code><b>loading</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Возникает, когда GridLayer начинает загружать тайлы.</td>
        </tr>
        <tr id="gridlayer-tileunload">
            <td><code><b>tileunload</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#tileevent">TileEvent</a></code></td>
            <td>Возникает, когда тайл удаляется с карты (например, при выходе его за пределы экрана).</td>
        </tr>
        <tr id="gridlayer-tileloadstart">
            <td><code><b>tileloadstart</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#tileevent">TileEvent</a></code></td>
            <td>Возникает, когда запрашивается тайл.</td>
        </tr>
        <tr id="gridlayer-tileerror">
            <td><code><b>tileerror</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#tileevent">TileEvent</a></code></td>
            <td>Возникает при ошибке загрузки тайла.</td>
        </tr>
        <tr id="gridlayer-tileload">
            <td><code><b>tileload</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#tileevent">TileEvent</a></code></td>
            <td>Возникает, когда тайл загружен.</td>
        </tr>
        <tr id="gridlayer-load">
            <td><code><b>load</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#tileevent">TileEvent</a></code></td>
            <td>Возникает, когда GridLayer загрузил все видимые тайлы.</td>
        </tr>
    </tbody>
</table>

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a> <!-- TODO: include events -->

#### Методы

<table id='gridlayer-methods'>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="gridlayer-bringtofront">
            <td><code><b>bringToFront</b>()</code></td>

            <td><code>this</code></td>
            <td>Позиционирует тайловый слой поверх остальных тайловых слоев.</td>
        </tr>
        <tr id="gridlayer-bringtoback">
            <td><code><b>bringToBack</b>()</code></td>

            <td><code>this</code></td>
            <td>Позиционирует тайловый слой под остальными тайловыми слоями.</td>
        </tr>
        <tr id="gridlayer-getattribution">
            <td><code><b>getAttribution</b>()</code></td>

            <td><code>String</code></td>
            <td>Используется элементом управления об авторстве, и возвращает соответствующие
                <a href="#gridlayer-attribution">свойства</a>.</td>
        </tr>
        <tr id="gridlayer-getcontainer">
            <td><code><b>getContainer</b>()</code></td>

            <td><code>String</code></td>
            <td>Возвращает HTML элемент, который содержит тайлы для данного слоя.</td>
        </tr>
        <tr id="gridlayer-setopacity">
            <td><code><b>setOpacity</b>(
                <nobr>&lt;Number&gt; <i>opacity</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Меняет значение <a href="#gridlayer-opacity">opacity</a> слоя.</td>
        </tr>
        <tr id="gridlayer-setzindex">
            <td><code><b>setZIndex</b>(
                <nobr>&lt;Number&gt; <i>zIndex</i> )</nobr>
            </code></td>

            <td><code>this</code></td>
            <td>Меняет значение <a href="#gridlayer-zindex">zIndex</a> слоя.</td>
        </tr>
        <tr id="gridlayer-isloading">
            <td><code><b>isLoading</b>()</code></td>

            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если хотя бы один тайл загружен не до конца.</td>
        </tr>
        <tr id="gridlayer-redraw">
            <td><code><b>redraw</b>()</code></td>

            <td><code>this</code></td>
            <td>Перересовывает все тайлы, запрашивая их повторно.</td>
        </tr>
        <tr id="gridlayer-gettilesize">
            <td><code><b>getTileSize</b>()</code></td>

            <td><code><a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a></code></td>
            <td>Возвращает значение опции <a href="#gridlayer-tilesize">tileSize</a> приведенное к объекту
                DG.Point. Используется методом <code>createTile()</code>.</td>
        </tr>
    </tbody>
</table>

#### Методы, используемые при наследовании

Слои, наследующие от <a href="#dggridlayer"><code>DG.GridLayer</code></a> должны поддерживать следующие методы:

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
	<tbody>
        <tr id="gridlayer-createtile">
            <td><code><b>createTile</b>(
                <nobr>&lt;Object&gt; <i>coords</i>,</nobr>
                <nobr>&lt;Function&gt; <i>done?</i> )</nobr>
            </code></td>

            <td><code>HTMLElement</code></td>
            <td>Вызывается только из API карт. Метод должен быть переопределен теми классами, которые расширяют
                <a href="#dggridlayer"><code>GridLayer</code></a>.
                Метод должен возвращать <code>HTMLElement</code> для позиции, координаты которой передаются в
                <code>coords</code>. Если указана функция обратного вызова <code>done</code>, она должна быть вызвана
                после загрузки и отрисовки тайла.
            </td>
        </tr>
    </tbody>
</table>

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/ru/manual/popup.md
================================================
## Попапы

Попап — это всплывающее окно, в котором можно отобразить произвольный HTML-код.
Попап связан с определенным местом на карте.

{toc}

### DG.Popup

Используется для создания и открытия попапов в определенных местах на карте.

Для открытия попапа можно использовать метод карты
<a href="/doc/maps/ru/manual/map#map-openpopup">Map.openPopup</a>, в таком случае
одновременно может быть открыт лишь один попап, либо метод
<a href="/doc/maps/ru/manual/map#map-addlayer">Map.addLayer</a> для отображения
любого количества попапов.

#### Пример использования

Включить отображение попапа по клику на маркер довольно просто:

	marker.bindPopup(popupContent).openPopup();

У дополнительных слоев, таких как ломаные, также есть метод bindPopup.
Вот более сложный пример отображения попапа:

	var popup = DG.popup()
		.setLatLng(latlng)
		.setContent('<p>Привет мир!<br />Это попап.</p>')
		.openOn(map);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="popup-dg-popup">
            <td><code><b>DG.popup</b>(
                    <nobr>&lt;<a href="#опции">Popup options</a>&gt; <i>options?</i></nobr>,
                    <nobr>&lt;<a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a>&gt; <i>source?</i>)</nobr>
                </code></td>
            <td>Создает объект Popup с переданными опциями, описывающими внешний вид и расположение попапа.
                Также вторым параметром можно передать объект <code>source</code>, указывающий привязку
                попапа к определенному объекту типа Layer.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="popup-maxwidth">
            <td><code><b>maxWidth</b></code></td>
            <td><code>Number </code></td>
            <td><code>300</code></td>
            <td>Максимальная ширина попапа в пикселях.</td>
        </tr>
        <tr id="popup-minwidth">
            <td><code><b>minWidth</b></code></td>
            <td><code>Number </code></td>
            <td><code>50</code></td>
            <td>Минимальная ширина попапа в пикселях.</td>
        </tr>
        <tr id="popup-maxheight">
            <td><code><b>maxHeight</b></code></td>
            <td><code>Number </code></td>
            <td><code>null</code></td>
            <td>Если значение установлено и содержимое попапа превышает заданную высоту,
                создается контейнер указанной высоты со скроллом.</td>
        </tr>
        <tr id="popup-autopan">
            <td><code><b>autoPan</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Установите значение в false, если не хотите, чтобы карта автоматически сдвигалась
                для полного отображения попапа.</td>
        </tr>
        <tr id="popup-autopanpaddingtopleft">
            <td><code><b>autoPanPaddingTopLeft</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
            <td>Задает расстояние от края попапа до левого верхнего угла карты при автоматическом сдвиге.</td>
        </tr>
        <tr id="popup-autopanpaddingbottomright">
            <td><code><b>autoPanPaddingBottomRight</b></code></td>
            <td><code>Point </code></td>
            <td><code>null</code></td>
            <td>Задает расстояние от края попапа до правого нижнего угла карты при автоматическом сдвиге.</td>
        </tr>
        <tr id="popup-autopanpadding">
            <td><code><b>autoPanPadding</b></code></td>
            <td><code>Point </code></td>
            <td><code>Point(5, 5)</code></td>
            <td>Задает расстояние от края попапа до границы карты при автоматическом сдвиге,
                устанавливает одинаковые значения для <code>autoPanPaddingBottomRight</code> и <code>autoPanPaddingTopLeft</code>.</td>
        </tr>
        <tr id="popup-keepinview">
            <td><code><b>keepInView</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Установите в <code>true</code>, если необходимо предотвратить вероятность перемещения
                попапа за пределы видимой области карты пока он открыт.</td>
        </tr>
        <tr id="popup-closebutton">
            <td><code><b>closeButton</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Отвечает за отображение кнопки закрытия попапа.</td>
        </tr>
        <tr id="popup-offset">
            <td><code><b>offset</b></code></td>
            <td><code>Point </code></td>
            <td><code>Point(0, 7)</code></td>
            <td>Устанавливает отступ позиции попапа. Удобно для управления "ножкой" попапа.</td>
        </tr>
        <tr id="popup-autoclose">
            <td><code><b>autoClose</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Установите эту опцию в <code>false</code>, если хотите изменить стандартное
                поведение, когда попап закрывается при кликах в область карты (устанавливается глобально
                с помощью метода карты
                <a href="/doc/maps/ru/manual/map#map-closepopuponclick">closePopupOnClick</a>)</td>
        </tr>
        <tr id="popup-zoomanimation">
            <td><code><b>zoomAnimation</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Анимировать ли попап при масштабировании. Отключите, если есть проблемы с
                отображением Flash содержимого внутри попапа.</td>
        </tr>
        <tr id="popup-classname">
            <td><code><b>className</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>Имя CSS-класса, которое будет назначено попапу.</td>
        </tr>
        <tr id="popup-pane">
            <td><code><b>pane</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;popupPane&#x27;</code></td>
            <td>Панель карты, на которую будет добавлен попап.</td>
        </tr>
        <tr id="popup-sprawling">
            <td><code><b>sprawling</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>false</code></td>
            <td>По умолчанию, ширина попапа подстраивается под ширину его контента и под ширину карты.
                Выставьте значение <code>true</code>, если хотите, чтобы выбиралась максимальная ширина,
                ограниченная только шириной карты.</td>
        </tr>
        <tr id="label-textdirection">
            <td><code><b>textDirection</b></code></td>
            <td><code>string</code></td>
            <td><code>'auto'</code></td>
            <td>Направление текста контента попапа. Может принимать одно из следующих значений: <code>'auto'</code>,
                <code>'rtl'</code>, <code>'ltr'</code>.</td>
        </tr>
    </tbody>
</table>

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

<table>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="popup-add">
            <td><code><b>add</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается при добавлении нового слоя на карту.</td>
        </tr>
        <tr id="popup-remove">
            <td><code><b>remove</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#event">Event</a></code></td>
            <td>Вызывается при удалении слоя с карты.</td>
        </tr>
    </tbody>
</table>

События попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

<table>
    <thead>
        <tr>
            <th>Событие</th>
            <th>Данные</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="popup-popupopen">
            <td><code><b>popupopen</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Вызывается при открытии попапа.</td>
        </tr>
        <tr id="popup-popupclose">
            <td><code><b>popupclose</b></code></td>
            <td><code>PopupEvent</code></td>
            <td>Вызывается при закрытии попапа.</td>
        </tr>
    </tbody>
</table>

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="popup-openon">
            <td><code><b>openOn</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/map#dgmap">Map</a>&gt; <i>map</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Добавляет попап на карту, предварительно закрыв другие попапы. Аналогично map.openPopup(popup).</td>
        </tr>
        <tr id="popup-getlatlng">
            <td><code><b>getLatLng</b>()</code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Возвращает географические координаты точки открытия попапа.</td>
        </tr>
        <tr id="popup-setlatlng">
            <td><code><b>setLatLng</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Устанавливает географические координаты точки открытия попапа.</td>
        </tr>
        <tr id="popup-getcontent">
            <td><code><b>getContent</b>()</code></td>
            <td><code>String|HTMLElement</code></td>
            <td>Возвращает содержимое основной части попапа.</td>
        </tr>
        <tr id="popup-setcontent">
            <td><code><b>setContent</b>(
                <nobr>&lt;String | HTMLElement | Function&gt; <i>htmlContent</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Задает содержимое основной части попапа. Может принимать HTML строку или DOM-элемент.
                Если метод получает функцию, данной функции будет передан исходный слой. Функция должна возвращать
                <code>String</code> или <code>HTMLElement</code></td>
        </tr>
        <tr id="popup-getheadercontent">
            <td><code><b>getHeaderContent</b>()</code></td>
            <td><code>String | HTMLElement</code></td>
            <td>Возвращает содержимое секции <code>header</code> попапа.</td>
        </tr>
        <tr id="popup-setheadercontent">
            <td><code><b>setHeaderContent</b>(
                <nobr>&lt;String | HTMLElement&gt; <i>htmlContent</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Задает содержимое секции <code>header</code> попапа. Может принимать HTML строку или DOM-элемент.</td>
        </tr>
        <tr id="popup-getfootercontent">
            <td><code><b>getFooterContent</b>()</code></td>
            <td><code>String|HTMLElement</code></td>
            <td>Возвращает содержимое секции <code>footer</code> попапа.</td>
        </tr>
        <tr id="popup-setfootercontent">
            <td><code><b>setFooterContent</b>(
                <nobr>&lt;String|HTMLElement&gt; <i>htmlContent</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Задает содержимое секции <code>footer</code> попапа. Может принимать HTML строку или DOM-элемент.</td>
        </tr>
        <tr id="popup-getelement">
            <td><code><b>getElement</b>()</code></td>
            <td><code>String|HTMLElement</code></td>
            <td>Алиас для <a href="#popup-getcontent">getContent()</a></td>
        </tr>
        <tr id="popup-update">
            <td><code><b>update</b>()</code></td>
            <td><code>null</code></td>
            <td>Обновляет содержимое попапа, разметку и позиционирование. Полезно при обновлении
                попапа, когда внутри него что-то изменилось, например, загрузилось изображение.</td>
        </tr>
        <tr id="popup-isopen">
            <td><code><b>isOpen</b>()</code></td>
            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, когда попап отображается на карте.</td>
        </tr>
        <tr id="popup-bringtofront">
            <td><code><b>bringToFront</b>()</code></td>
            <td><code>this</code></td>
            <td>Помещает данный попап выше других попапов (в пределах одной панели карты)</td>
        </tr>
        <tr id="popup-bringtoback">
            <td><code><b>bringToBack</b>()</code></td>
            <td><code>this</code></td>
            <td>Помещает данный попап под другими попапами (в пределах одной панели карты)</td>
        </tr>
    </tbody>
</table>

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/ru/manual/raster-layers.md
================================================
## Растровые слои

В данном разделе рассматривается работа с растровыми слоями, которые могут представлять собой тайловые слои
или изображения привязанные к географическим границам.

{toc}

### DG.TileLayer

Используется для загрузки и отображения тайловых слоев на карте.
Расширяет <a href="/doc/maps/ru/manual/other-layers#dggridlayer">GridLayer</a>.

#### Пример использования

    DG.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png?{foo}', {foo: 'bar'}).addTo(map);

##### Шаблон URL

Строка, представленная в следующем виде:

    'http://{s}.somedomain.com/blabla/{z}/{x}/{y}{r}.png'

Вы можете использовать свои ключи в шаблоне, которые будут подставлены из опций TileLayer:

    DG.tileLayer('http://{s}.somedomain.com/{foo}/{z}/{x}/{y}.png', {foo: 'bar'});

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-dg-tilelayer">
            <td><code>
                    <b>DG.tilelayer</b>(
                    <nobr>&lt;String&gt;</nobr> <i>urlTemplate</i>,
                    <nobr><i>options</i></nobr>)
                </code></td>
            <td>Создает экземпляр объекта тайлового слоя с данным шаблоном URL и необязательным объектом опций.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table id="tilelayer-options">
    <thead>
        <tr>
			<th>Опция</th>
			<th>Тип</th>
			<th>По умолчанию</th>
			<th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-minzoom">
            <td><code><b>minZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>0</code></td>
            <td>Минимальный уровень масштаба.</td>
        </tr>
        <tr id="tilelayer-maxzoom">
            <td><code><b>maxZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>18</code></td>
            <td>Максимальный уровень масштаба.</td>
        </tr>
        <tr id="tilelayer-maxnativezoom">
            <td><code><b>maxNativeZoom</b></code></td>
            <td><code>Number </code></td>
            <td><code>null</code></td>
            <td>Максимальный уровень масштаба, который есть у тайлов. Если этот параметр установлен,
                тайлы всех уровней увеличения, выше чем <code>maxNativeZoom</code>, будут загружены
                из уровня <code>maxNativeZoom</code> и автоматически отмасштабированы.</td>
        </tr>
        <tr id="tilelayer-subdomains">
            <td><code><b>subdomains</b></code></td>
            <td><code>String|String[] </code></td>
            <td><code>&#x27;abc&#x27;</code></td>
            <td>Под-домены тайловой службы. Могут быть переданы в форме строки (где каждая буква, это имя
                под-домена) или в форме массива строк.</td>
        </tr>
        <tr id="tilelayer-errortileurl">
            <td><code><b>errorTileUrl</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>URL на тайл изображения, который надо показывать, если загрузка тайла не удалась.</td>
        </tr>
        <tr id="tilelayer-zoomoffset">
            <td><code><b>zoomOffset</b></code></td>
            <td><code>Number </code></td>
            <td><code>0</code></td>
            <td>Уровень масштаба, который используется в URL тайлов, будет скорректирован
                с учетом данного смещения.</td>
        </tr>
        <tr id="tilelayer-tms">
            <td><code><b>tms</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code>, инвертирует ось Y нумерации тайлов (включите эту опцию
                для <a href="https://en.wikipedia.org/wiki/Tile_Map_Service">TMS</a> сервисов).</td>
        </tr>
        <tr id="tilelayer-zoomreverse">
            <td><code><b>zoomReverse</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code>, уровень масштаба используемый в URL тайлов будет
                инвертировано (<code>maxZoom - zoom</code> вместо <code>zoom</code>) </td>
        </tr>
        <tr id="tilelayer-detectretina">
            <td><code><b>detectRetina</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code> и пользователь использует retina дисплей, тогда будет запрошено
                четыре тайла вместо одного. Эти тайлы будут в два раза меньше стандартного размера и на
                один уровень масштабирования больше, для того чтобы адаптироваться под более
                высокую плотность пикселей.</td>
        </tr>
        <tr id="tilelayer-crossorigin">
            <td><code><b>crossOrigin</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code>, у всех тайлов атрибут crossOrigin будет установлен в &#39;&#39;.
                Это необходимое условие, если вы хотите получить доступ к исходным тайлам на уровне пикселей.</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="/doc/maps/ru/manual/other-layers#gridlayer-options">GridLayer</a> <!-- TODO: include options -->


#### События

События, унаследованные от <a href="/doc/maps/ru/manual/other-layers#gridlayer-events">GridLayer</a> <!-- TODO: include events -->

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

<table id="tilelayer-methods">
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-seturl">
            <td><code><b>setUrl</b>(
                <nobr>&lt;String&gt; <i>url</i></nobr>
                <nobr>&lt;Boolean&gt; <i>noRedraw?</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Обновляет URL шаблон слоя и перерисовывает его (если параметр <code>noRedraw</code>
                не установлен в <code>true</code>). </td>
        </tr>
        <tr id="tilelayer-createtile">
            <td><code><b>createTile</b>(
                <nobr>&lt;Object&gt;</nobr> <i>coords</i>,
                <nobr>&lt;Function&gt;</nobr> <i>done?</i>)</nobr>
            </code></td>
            <td><code>HTMLElement</code></td>
            <td>Вызывается только внутри библиотеки. Перегружает метод
                <a href="/doc/maps/ru/manual/other-layers#gridlayer-createtile"><code>createTile()</code></a>
                класса GridLayer. Метод возвращает HTML-элемент <code>&lt;img&gt;</code> с соответствующим
                изображением по переданному аргументу <code>coords</code>. Функция обратного вызова
                <code>done</code> будет вызван, когда тайл будет загружен.</td>
        </tr>
    </tbody>
</table>

##### Методы расширения

Слои, расширяющие <a href="#dgtilelayer">TileLayer</a>, могут реализовать следующий метод:

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-gettileurl">
            <td><code><b>getTileUrl</b>(<nobr>&lt;Object&gt; <i>coords</i>)</nobr></code></td>
            <td><code>String</code></td>
            <td>Вызывается только внутри библиотеки, возвращает URL для тайла, расположенного по
                переданным координатам. Классы, расширяющие <a href="#dgtilelayer"><code>TileLayer</code></a>,
                могут перегружать эту функцию, для того чтобы предоставить собственные схемы
                именования URL тайлов.</td>
        </tr>
    </tbody>
</table>

Методы, унаследованные от GridLayer <a href="/doc/maps/ru/manual/other-layers#gridlayer-methods">GridLayer</a> <!-- TODO: include methods -->

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.TileLayer.wms

Используется для отображения WMS сервисов как тайловых слоев на карте. Расширяет <a href="#dgtilelayer">TileLayer</a>.

#### Пример использования

    var nexrad = DG.tileLayer.wms("http://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0r.cgi", {
        layers: 'nexrad-n0r-900913',
        format: 'image/png',
        transparent: true,
        attribution: "Погодные данные © 2012 IEM Nexrad"
    });

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-wms-dg-tilelayer-wms">
            <td><code><b>DG.tileLayer.wms</b>(
                <nobr>&lt;String&gt; <i>baseUrl</i></nobr>,
                <nobr>&lt;<a href="#tilelayer-wms-options">TileLayer.WMS options</a>&gt; <i>options</i>)</nobr>
            </code></td>
            <td>Создает экземпляр объекта WMS тайлового слоя по переданному URL WMS-сервиса и объекту WMS-опций.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table id="tilelayer-wms-options">
    <thead>
        <tr>
			<th>Опция</th>
			<th>Тип</th>
			<th>По умолчанию</th>
			<th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-wms-layers">
            <td><code><b>layers</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td><strong>(требуется)</strong> Разделенный запятыми список WMS-слоев для отображения.</td>
        </tr>
        <tr id="tilelayer-wms-styles">
            <td><code><b>styles</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>Разделенный запятыми список WMS-стилей.</td>
        </tr>
        <tr id="tilelayer-wms-format">
            <td><code><b>format</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;image/jpeg&#x27;</code></td>
            <td>Формат изображений WMS (используйте <code>&#39;image/png&#39;</code> для слоев с прозрачностью).</td>
        </tr>
        <tr id="tilelayer-wms-transparent">
            <td><code><b>transparent</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code>, WMS-сервис вернет изображения с прозрачностью.</td>
        </tr>
        <tr id="tilelayer-wms-version">
            <td><code><b>version</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;1.1.1&#x27;</code></td>
            <td>Версия WMS сервиса, которую следует использовать</td>
        </tr>
        <tr id="tilelayer-wms-crs">
            <td><code><b>crs</b></code></td>
            <td><code>CRS </code></td>
            <td><code>null</code></td>
            <td>Система координат (CRS), котрую следует использовать при WMS-запросах, по умолчанию
                установлена в CRS карты. Не изменяйте эту настройку, если вы не уверены в том, что
                она означает.</td>
        </tr>
        <tr id="tilelayer-wms-uppercase">
            <td><code><b>uppercase</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code>, ключи параетров WMS запросов будут переведены в верхний регистр.</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="#tilelayer-options">TileLayer</a> <!-- TODO: include options -->

Опции, унаследованные от <a href="/doc/maps/ru/manual/other-layers#gridlayer-options">GridLayer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/other-layers#gridlayer-events">GridLayer</a> <!-- TODO: include events -->

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="tilelayer-wms-setparams">
            <td><code><b>setParams</b>(
                <nobr>&lt;Object&gt; <i>params</i></nobr>,
                <nobr>&lt;Boolean&gt; <i>noRedraw?</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Расширяет объект новыми параметрами и заново запрашивает тайлы для текущего экрана
                (если <code>noRedraw</code> не был установлен в true).</td>
        </tr>
    </tbody>
</table>

Методы, унаследованные от  TileLayer <a href="#tilelayer-methods">TileLayer</a> <!-- TODO: include methods -->

Методы, унаследованные от GridLayer <a href="/doc/maps/ru/manual/other-layers#gridlayer-methods">GridLayer</a> <!-- TODO: include methods -->

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.ImageOverlay

Используется для загрузки и отображения указанного изображения в определенной области карты. Расширяет Layer.

#### Пример использования

    var imageUrl = 'http://www.lib.utexas.edu/maps/historical/newark_nj_1922.jpg',
        imageBounds = [[40.712216, -74.22655], [40.773941, -74.12544]];
    DG.imageOverlay(imageUrl, imageBounds).addTo(map);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="imageoverlay-dg-imageoverlay">
            <td><code><b>DG.imageOverlay</b>(
                <nobr>&lt;String&gt; <i>imageUrl</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>bounds</i></nobr>,
                <nobr>&lt;ImageOverlay options&gt; <i>options?</i></nobr>)
            </code></td>
            <td>Создает экземпляр слоя с изображением по переданному URL изображения и
                географическим координатам, к которым оно привязано.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
			<th>Опция</th>
			<th>Тип</th>
			<th>По умолчанию</th>
			<th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="imageoverlay-opacity">
            <td><code><b>opacity</b></code></td>
            <td><code>Number </code></td>
            <td><code>1.0</code></td>
            <td>Прозрачность слоя с изображением.</td>
        </tr>
        <tr id="imageoverlay-alt">
            <td><code><b>alt</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;&#x27;</code></td>
            <td>Текст для атрибута <code>alt</code> изобаржения.</td>
        </tr>
        <tr id="imageoverlay-interactive">
            <td><code><b>interactive</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code>, слой изображения будет генерировать события мыши при кликах или наведении курсора.</td>
        </tr>
        <tr id="imageoverlay-crossorigin">
            <td><code><b>crossOrigin</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>false</code></td>
            <td>Если <code>true</code>, атрибут изображения <code>crossOrigin</code> будет установлен в &#39;&#39;.
                Это необходимое условие, если вы хотите получить доступ к изображению на уровне пикселей.</td>
        </tr>
    </tbody>
</table>

Оцпии, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="imageoverlay-setopacity">
            <td><code><b>setOpacity</b>()</nobr></code></td>
            <td><code>this</code></td>
            <td>Устанавливает прозрачность слоя.</td>
        </tr>
        <tr id="imageoverlay-bringtofront">
            <td><code><b>bringToFront</b>()</nobr></code></td>
            <td><code>this</code></td>
            <td>Перемещает слой выше других слоев.</td>
        </tr>
        <tr id="imageoverlay-bringtoback">
            <td><code><b>bringToBack</b>()</nobr></code></td>
            <td><code>this</code></td>
            <td>Перемещает слой ниже других слоев.</td>
        </tr>
        <tr id="imageoverlay-seturl">
            <td><code><b>setUrl</b>(<nobr>&lt;String&gt; <i>url</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Изменяет URL изображения.</td>
        </tr>
    </tbody>
</table>

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/ru/manual/utils.md
================================================
## Вспомогательные классы

{toc}

### DG.Browser

Объект со статическими свойствами, описывающими браузер пользователя, например:

    if (DG.Browser.ie6) {
        alert('Вам срочно нужно обновить свой браузер!');
    }

#### Свойства

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="browser-ie">
            <td><code><b>ie</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для всех версий Internet Explorer (не Edge).</td>
        </tr>
        <tr id="browser-ielt9">
            <td><code><b>ielt9</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для всех версий Internet Explorer ниже версии 9.</td>
        </tr>
        <tr id="browser-edge">
            <td><code><b>edge</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для браузера Edge.</td>
        </tr>
        <tr id="browser-webkit">
            <td><code><b>webkit</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для браузеров на основе WebKit, таких как Chrome и Safari (включая мобильные версии).</td>
        </tr>
        <tr id="browser-gecko">
            <td><code><b>gecko</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для браузеров на основе gecko, таких как Firefox.</td>
        </tr>
        <tr id="browser-android">
            <td><code><b>android</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для мобильных браузеров работающих на базе платформы Android.</td>
        </tr>
        <tr id="browser-android23">
            <td><code><b>android23</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для мобильных браузеров на старых версиях Android устройств (2 и 3).</td>
        </tr>
        <tr id="browser-chrome">
            <td><code><b>chrome</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для браузера Chrome.</td>
        </tr>
        <tr id="browser-safari">
            <td><code><b>safari</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для браузера Safari.</td>
        </tr>
        <tr id="browser-ie3d">
            <td><code><b>ie3d</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для всех версий Internet Explorer, поддерживающих CSS transform.</td>
        </tr>
        <tr id="browser-webkit3d">
            <td><code><b>webkit3d</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для всех браузеров на основе WebKit, поддерживающих CSS transform.</td>
        </tr>
        <tr id="browser-gecko3d">
            <td><code><b>gecko3d</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для всех браузеров на основе gecko, поддерживающих CSS transform.</td>
        </tr>
        <tr id="browser-opera12">
            <td><code><b>opera12</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для всех версий Opera, поддерживающих CSS transform (версия 12+).</td>
        </tr>
        <tr id="browser-any3d">
            <td><code><b>any3d</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для всех браузеров, поддерживающих CSS transform.</td>
        </tr>
        <tr id="browser-mobile">
            <td><code><b>mobile</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для браузеров, работающих на современных мобильных устройствах.</td>
        </tr>
        <tr id="browser-mobilewebkit">
            <td><code><b>mobileWebkit</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для мобильных браузеров на основе WebKit.</td>
        </tr>
        <tr id="browser-mobilewebkit3d">
            <td><code><b>mobileWebkit3d</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для мобильных браузеров на основе WebKit, поддерживающих CSS transform.</td>
        </tr>
        <tr id="browser-mobileopera">
            <td><code><b>mobileOpera</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для мобильной версии Opera.</td>
        </tr>
        <tr id="browser-mobilegecko">
            <td><code><b>mobileGecko</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для мобильных браузеров на основе gecko.</td>
        </tr>
        <tr id="browser-touch">
            <td><code><b>touch</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для всех браузеров, поддерживающих <a href="https://developer.mozilla.org/docs/Web/API/Touch_events">touch events</a>.</td>
        </tr>
        <tr id="browser-mspointer">
            <td><code><b>msPointer</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для браузеров, поддерживающих touch events модель от Microsoft (например, IE10).</td>
        </tr>
        <tr id="browser-pointer">
            <td><code><b>pointer</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для всех браузеров, поддерживающих <a href="https://msdn.microsoft.com/en-us/library/dn433244%28v=vs.85%29.aspx">pointer events</a>.</td>
        </tr>
        <tr id="browser-retina">
            <td><code><b>retina</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для браузеров, работающих на устройствах с Retina экраном.</td>
        </tr>
        <tr id="browser-canvas">
            <td><code><b>canvas</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для браузеров, поддерживающих <a href="https://developer.mozilla.org/docs/Web/API/Canvas_API"><code>&lt;canvas&gt;</code></a>.</td>
        </tr>
        <tr id="browser-vml">
            <td><code><b>vml</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для браузеров, поддерживающих <a href="https://ru.wikipedia.org/wiki/VML">VML</a>.</td>
        </tr>
        <tr id="browser-svg">
            <td><code><b>svg</b></code></td>
            <td><code>Boolean</code></td>
            <td><code>true</code> для браузеров, поддерживающих <a href="https://developer.mozilla.org/docs/Web/SVG">SVG</a>.</td>
        </tr>
    </tbody>
</table>

### DG.Util

Общие служебные методы и свойства.

#### Функции

<table>
    <thead>
        <tr>
            <th>Функция</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="util-extend">
            <td><code><b>extend</b>(
                <nobr>&lt;Object&gt; <i>dest</i>,</nobr>
                <nobr>&lt;Object&gt; <i>src?</i> )</nobr>
            </code></td>

            <td><code>Object</code></td>
            <td>Объединяет свойства объекта <code>src</code> (или нескольких объектов) и свойства объекта
                <code>dest</code> и возвращает последний. Также доступен под псевдонимом <code>DG.extend</code>.</td>
        </tr>
        <tr id="util-create">
            <td><code><b>create</b>(
                <nobr>&lt;Object&gt; <i>proto</i>,</nobr>
                <nobr>&lt;Object&gt; <i>properties?</i> )</nobr>
            </code></td>

            <td><code>Object</code></td>
            <td>Полифил для <a href="https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/create">Object.create</a></td>
        </tr>
        <tr id="util-bind">
            <td><code><b>bind</b>(
                <nobr>&lt;Function&gt; <i>fn</i>, <i>…</i> )</nobr>
            </code></td>

            <td><code>Function</code></td>
            <td>Возвращает функцию, которая выполняет функцию <code>fn</code> с определенным объектом контекста
                <code>obj</code> (так, чтобы ключевое слово <code>this</code> внутри функции указывало на
                <code>obj</code>). Также доступно под псевдонимом <code>DG.bind</code>.</td>
        </tr>
        <tr id="util-stamp">
            <td><code><b>stamp</b>(
                <nobr>&lt;Object&gt; <i>obj</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Возвращает уникальный ID объекта, создавая его при необходимости. Полезно для получения быстрого
                доступа к объекту, находящемуся в группе.</td>
        </tr>
        <tr id="util-throttle">
            <td><code><b>throttle</b>(
                <nobr>&lt;Function&gt; <i>fn</i>,</nobr>
                <nobr>&lt;Number&gt; <i>time</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context</i> )</nobr>
            </code></td>

            <td><code>Function</code></td>
            <td>Возвращает обертку над функцией <code>fn</code>, которая гарантирует, что функция не будет
                вызвана более чем один раз в заданный интервал времени <code>time</code>
                (например, используется при запросах к тайлам во время перетаскивания карты), опционально
                можно передать контекст (<code>context</code>), с которым будет вызываться функция.</td>
        </tr>
        <tr id="util-wrapnum">
            <td><code><b>wrapNum</b>(
                <nobr>&lt;Number&gt; <i>num</i>,</nobr>
                <nobr>&lt;Number[]&gt; <i>range</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>includeMax?</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Возвращает число <code>num</code> приведенное к диапазону <code>range</code> (modulo).
                Получившееся значение будет всегда меньше <code>range[1]</code>, если только опция
                <code>includeMax</code> не выставлена в <code>true</code>.</td>
        </tr>
        <tr id="util-falsefn">
            <td><code><b>falseFn</b>()</code></td>

            <td><code>Function</code></td>
            <td>Возвращает функцию, вызов которой всегда будет давать результат <code>false</code>.</td>
        </tr>
        <tr id="util-formatnum">
            <td><code><b>formatNum</b>(
                <nobr>&lt;Number&gt; <i>num</i>,</nobr>
                <nobr>&lt;Number&gt; <i>digits?</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Возвращает число <code>num</code>, округленное до <code>digits</code> десятичных знаков
                (5 знаков по умолчанию).</td>
        </tr>
        <tr id="util-trim">
            <td><code><b>trim</b>(
                <nobr>&lt;String&gt; <i>str</i> )</nobr>
            </code></td>

            <td><code>String</code></td>
            <td>Полифил для <a href="https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim">String.prototype.trim</a></td>
        </tr>
        <tr id="util-splitwords">
            <td><code><b>splitWords</b>(
                <nobr>&lt;String&gt; <i>str</i> )</nobr>
            </code></td>

            <td><code>String[]</code></td>
            <td>Обрезает и разделяет строку на части, используя в качестве разделителя пробел, возвращает массив с этими частями.</code></td>
        </tr>
        <tr id="util-setoptions">
            <td><code><b>setOptions</b>(
                <nobr>&lt;Object: options: Object&gt; <i>obj</i> )</nobr>
            </code></td>

            <td><code>Object</code></td>
            <td>Объединяет свойства <code>options</code> со свойствами объекта <code>obj</code>, возвращая
                получившийся объект. См. <code>Class options</code>. Также доступен под псевдонимом <code>DG.setOptions</code>.</td>
        </tr>
        <tr id="util-getparamstring">
            <td><code><b>getParamString</b>(
                <nobr>&lt;Object&gt; <i>obj</i>,</nobr>
                <nobr>&lt;String&gt; <i>existingUrl?</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>uppercase?</i> )</nobr>
            </code></td>

            <td><code>String</code></td>
            <td>Преобразует объект в URL-строку, например, <nobr><code>{a: &quot;foo&quot;, b: &quot;bar&quot;}</code></nobr>
                будет преобразован в <code>&#39;?a=foo&amp;b=bar&#39;</code>. Если задан параметр <code>existingUrl</code>
                результирующая строка будет подготовлена для добавления в конец переданного URL. Также возможно приведение названий
                свойств к верхнему регистру (параметр <code>uppercase</code>). Простейший шаблонизатор также воспринимает
                строки в формате <code>&#39;Hello {a}, {b}&#39;</code> и объект вида <code>{a: &#39;foo&#39;, b: &#39;bar&#39;}</code>.
                При таком вызове метод возвращает строку <code>(&#39;Hello foo, bar&#39;)</code>.</td>
        </tr>
        <tr id="util-isarray">
            <td><code><b>isArray</b>(<i>obj</i>)</code></td>

            <td><code>Boolean</code></td>
            <td>Полифил для <a href="https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray">Array.isArray</a></td>
        </tr>
        <tr id="util-indexof">
            <td><code><b>indexOf</b>()</code></td>

            <td><code>Number</code></td>
            <td>Полифил для <a href="https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf">Array.prototype.indexOf</a></td>
        </tr>
        <tr id="util-requestanimframe">
            <td><code><b>requestAnimFrame</b>(
                <nobr>&lt;Function&gt; <i>fn</i>,</nobr>
                <nobr>&lt;Object&gt; <i>context?</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>immediate?</i> )</nobr>
            </code></td>

            <td><code>requestId: Number</code></td>
            <td>Использует планировщик для вызова функции <code>fn</code> при событии обновлении окна браузера (repaint).
                Функция <code>fn</code> вызывается с контекстом <code>context</code>, если он задан. Когда задан параметр
                <code>immediate</code>, <code>fn</code> функция вызывается сразу же, если браузер не поддерживает нативно
                <a href="https://developer.mozilla.org/docs/Web/API/window/requestAnimationFrame"><code>window.requestAnimationFrame</code></a>,
                в противном случае вызов откладывается, до возникновения события перерисовки. Возвращает id, который может
                быть использован для отмены задания планировщика.</td>
        </tr>
        <tr id="util-cancelanimframe">
            <td><code><b>cancelAnimFrame</b>(
                <nobr>&lt;Number&gt; <i>id</i> )</nobr>
            </code></td>
            <td><code></code></td>
            <td>Отменяет предыдущий <code>requestAnimFrame</code>. См. также <a href="https://developer.mozilla.org/docs/Web/API/window/cancelAnimationFrame">window.cancelAnimationFrame</a>.</td>
        </tr>
    </tbody>
</table>

#### Свойства

<table>
    <thead>
        <tr>
            <th>Свойство</th>
            <th>Тип</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="util-lastid">
            <td><code><b>lastId</b></code></td>
            <td><code>Number</code></td>
            <td>Последний уникальный ID, используемый <a href="#util-stamp"><code>stamp()</code></a></td>
        </tr>
        <tr id="util-emptyimageurl">
            <td><code><b>emptyImageUrl</b></code></td>
            <td><code>String</code></td>
            <td>URI, содержащий пустое GIF изображение, закодированное в base64. Используется для освобождения памяти
                неиспользуемых картинок в мобильных WebKit браузерах (память освобождается установкой свойства
                <code>src</code> в данное значение).</td>
        </tr>
    </tbody>
</table>

### DG.LineUtil

Набор методов для обработки ломаных.

#### Функции

<table>
    <thead>
        <tr>
            <th>Функция</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="lineutil-simplify">
            <td><code><b>simplify</b>(
                <nobr>&lt;Point[]&gt; <i>points</i>,</nobr>
                <nobr>&lt;Number&gt; <i>tolerance</i> )</nobr>
            </code></td>

            <td><code>Point[]</code></td>
            <td>Уменьшает количество точек в ломаной и возвращает новую упрощенную ломаную. Позволяет увеличить
                производительность обработки/отображения ломаных на карте. Параметр <code>tolerance</code> влияет
                на величину упрощения (чем меньше значение, тем лучше качество геометрии и ниже производительность).</td>
        </tr>
        <tr id="lineutil-pointtosegmentdistance">
            <td><code><b>pointToSegmentDistance</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>p</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>p1</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>p2</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Возвращает расстояние между точкой <code>p</code> и сегментом между точками <code>p1</code> и <code>p2</code>.</td>
        </tr>
        <tr id="lineutil-closestpointonsegment">
            <td><code><b>closestPointOnSegment</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>p</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>p1</i></nobr>,
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgpoint">Point</a>&gt; <i>p2</i> )</nobr>
            </code></td>

            <td><code>Number</code></td>
            <td>Возвращает ближайшую точку на сегменте <code>p1</code> <code>p2</code> до точки <code>p</code>.</td>
        </tr>
    </tbody>
</table>

### DG.PolyUtil

Набор служебных функций для работы с многоугольниками.

#### Функции

<table>
    <thead>
        <tr>
            <th>Функция</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
    </thead>
    <tbody>
        <tr id="polyutil-clippolygon">
		    <td><code><b>clipPolygon</b>(
		        <nobr>&lt;Point[]&gt; <i>points</i>,</nobr>
		        <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dgbounds">Bounds</a>&gt; <i>bounds</i>,</nobr>
		        <nobr>&lt;Boolean&gt; <i>round?</i> )</nobr>
		    </code></td>

    		<td><code>Point[]</code></td>
    		<td>Обрезает многоугольник, заданный координатами <code>points</code> по заданным границам
    		    (используя алгоритм <a href="https://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman_algorithm">Sutherland-Hodgeman</a>а).</td>
    	</tr>
    </tbody>
</table>


================================================
FILE: src/doc/ru/manual/vector-layers.md
================================================
## Векторные слои

В данном разделе рассматривается работа с векторными слоями, представляющие собой геометрические
объекты на карте: окружности, ломаные линии, многоугольники.

{toc}

### DG.Path

Абстрактный класс, содержащий базовые опции и константы векторных слоев (Polygon, Polyline, Circle).
Не используйте этот класс напрямую. Расширяет <a href="/doc/maps/ru/manual/base-classes#dglayer">Layer</a>.

#### Опции

<table id="dgpath-options">
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="path-stroke">
            <td><code><b>stroke</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Нужно ли рисовать границу фигуры. Установите значение в <code>false</code>,
                чтобы отключить границы многоугольников или окружностей.</td>
        </tr>
        <tr id="path-color">
            <td><code><b>color</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;#3388ff&#x27;</code></td>
            <td>Цвет границы.</td>
        </tr>
        <tr id="path-weight">
            <td><code><b>weight</b></code></td>
            <td><code>Number </code></td>
            <td><code>3</code></td>
            <td>Ширина границы в пикселях.</td>
        </tr>
        <tr id="path-opacity">
            <td><code><b>opacity</b></code></td>
            <td><code>Number </code></td>
            <td><code>1.0</code></td>
            <td>Прозрачность границы.</td>
        </tr>
        <tr id="path-linecap">
            <td><code><b>lineCap</b></code></td>
            <td><code>String</code></td>
            <td><code>&#x27;round&#x27;</code></td>
            <td>Строка, которая определяет вид границы,
                <a target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap">
                на концах ломаной</a>.</td>
        </tr>
        <tr id="path-linejoin">
            <td><code><b>lineJoin</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;round&#x27;</code></td>
            <td>Строка, которая определяет вид границы,
                <a target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin">
                на изгибах</a> ломаной.</td>
        </tr>
        <tr id="path-dasharray">
            <td><code><b>dashArray</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
            <td>Строка <a target="_blank" href="https://developer.mozilla.org/en/SVG/Attribute/stroke-dasharray">шаблона границы</a>.
                Не работает на canvas слоях (например, Android 2).</td>
        </tr>
        <tr id="path-dashoffset">
            <td><code><b>dashOffset</b></code></td>
            <td><code>String </code></td>
            <td><code>null</code></td>
            <td>Строка, которая определяет
                <a href="https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-dashoffset">расстояние,
                через которое начинается штриховка</a>. Не работает на canvas слоях (например, Android 2).</td>
        </tr>
        <tr id="path-fill">
            <td><code><b>fill</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>depends</code></td>
            <td>Заполнять ли фигуру цветом. Установите значение в <code>false</code>,
                чтобы отключить заполнение многоугольников или окружностей.</td>
        </tr>
        <tr id="path-fillcolor">
            <td><code><b>fillColor</b></code></td>
            <td><code>String </code></td>
            <td><code>*</code></td>
            <td>Цвет заливки. Цвет по умолчанию определяется опцией <a href="#path-color"><code>color</code></a>.</td>
        </tr>
        <tr id="path-fillopacity">
            <td><code><b>fillOpacity</b></code></td>
            <td><code>Number </code></td>
            <td><code>0.2</code></td>
            <td>Прозрачность заливки.</td>
        </tr>
        <tr id="path-fillrule">
            <td><code><b>fillRule</b></code></td>
            <td><code>String </code></td>
            <td><code>&#x27;evenodd&#x27;</code></td>
            <td>Строка, которая задает,
                <a href="https://developer.mozilla.org/docs/Web/SVG/Attribute/fill-rule">как определяется
                внутренняя область фигуры</a>.</td>
        </tr>
        <tr id="path-interactive">
            <td><code><b>interactive</b></code></td>
            <td><code>Boolean </code></td>
            <td><code>true</code></td>
            <td>Если <code>false</code>, векторный слой не будет генерировать события мыши и будет
                вести себя, как часть нижележащего слоя карты.</td>
        </tr>
        <tr id="path-renderer">
            <td><code><b>renderer</b></code></td>
            <td><code><a href="/doc/maps/ru/manual/base-classes#dgrenderer">Renderer</a></code></td>
            <td><code></code></td>
            <td>Использовать этот экземпляр <a href="/doc/maps/ru/manual/base-classes#dgrenderer"><code>Renderer</code></a>
                для данного векторного объекта. Переопределяет
                <a href="/doc/maps/ru/manual/map#map-renderer">renderer карты</a>, установленный по умолчанию.</td>
        </tr>
        <tr id="path-classname">
            <td><code><b>className</b></code></td>
            <td><code>string </code></td>
            <td><code>null</code></td>
            <td>Добавляет класс в соотвествующий атрибут элемента (только для SVG).</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

<table id="dgpath-methods">
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="path-redraw">
            <td><code><b>redraw</b>()</code></td>
            <td><code>this</code></td>
            <td>Перерисовывает слой. Удобно при изменении его координат.</td>
        </tr>
        <tr id="path-setstyle">
            <td><code>
                <b>setStyle</b>(
                <nobr>&lt;<a href="#dgpath-options">Path options</a>&gt; <i>style</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Изменяет внешний вид объекта с помощью <a href="#dgpath-options">опций класса Path</a>.</td>
        </tr>
        <tr id="path-bringtofront">
            <td><code><b>bringToFront</b>()</code></td>
            <td><code>this</code></td>
            <td>Позиционирует слой поверх всех остальных.</td>
        </tr>
        <tr id="path-bringtoback">
            <td><code><b>bringToBack</b>()</code></td>
            <td><code>this</code></td>
            <td>Позиционирует слой под остальными.</td>
        </tr>
    </tbody>
</table>

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.Polyline

Класс для отрисовки ломаных линий на карте. Расширяет <a href="#dgpath">Path</a>.

#### Пример использования

    // создает ломаную красного цвета из массива точек LatLng
    var latlngs = [
        [-122.68, 45.51],
        [-122.43, 37.77],
        [-118.2, 34.04]
    ];
    var polyline = DG.polyline(latlngs, {color: 'red'}).addTo(map);
    // увеличиваем масштаб так, чтобы было видно всю ломаную
    map.fitBounds(polyline.getBounds());

Вы также можете передать многомерный массиив, который представляет собой фигуру MultiPolyline:

    // создает красную ломаную из массива массивов точек LatLng
    var latlngs = [
        [[-122.68, 45.51],
         [-122.43, 37.77],
         [-118.2, 34.04]],
        [[-73.91, 40.78],
         [-87.62, 41.83],
         [-96.72, 32.76]]
    ];

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Использование</th>
        </tr>
	</thead>
    <tbody>
        <tr id="polyline-dg-polyline">
            <td><code><b>DG.polyline</b>(
                <nobr>&lt;LatLng[]&gt; <i>latlngs</i></nobr>,
                <nobr>&lt;<a href="#dgpath-options">Path options</a>&gt; <i>options?</i>)</nobr>
            </code></td>
            <td>Создает объект ломаной по переданному массиву географических точек и необязательному объекту опций.
                Вы можете создать объект <a href="#dgpolyline"><code>Polyline</code></a>, состоящий из
                множества линий (так называемый <code>MultiPolyline</code>), передав массив массивов
                географических точек.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table id="dgpolyline-options">
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="polyline-smoothfactor">
            <td><code><b>smoothFactor</b></code></td>
            <td><code>Number </code>
            <td><code>1.0</code></td>
            <td>Степень упрощения ломаной на каждом уровне масштаба. Большее значение означает более высокую
                производительность, но худшее качество, меньшее же значение &mdash; наоборот.</td>
        </tr>
        <tr id="polyline-noclip">
            <td><code><b>noClip</b></code></td>
            <td><code>Boolean: false</code>
            <td><code></code></td>
            <td>Отключает отсечение ломаной.</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="#dgpath-options">Path</a> <!-- TODO: include options -->

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапов, унаследованные <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

<table id="dgpolyline-methods">
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="polyline-togeojson">
            <td><code><b>toGeoJSON</b>()</code></td>
            <td><code>Object</code></td>
            <td>Возвращает <a href="http://en.wikipedia.org/wiki/GeoJSON">GeoJSON</a>
                представление ломаной (GeoJSON LineString или <code>MultiLineString</code>).</td>
        </tr>
        <tr id="polyline-getlatlngs">
            <td><code><b>getLatLngs</b>()</code></td>
            <td><code>LatLng[]</code></td>
            <td>Возвращает массив точек объекта или массив массивов точек, в случае мультиломаной.</td>
        </tr>
        <tr id="polyline-setlatlngs">
            <td><code><b>setLatLngs</b>(<nobr>&lt;LatLng[]&gt; <i>latlngs</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Заменяет все точки ломаной данными из переданного массива.</td>
        </tr>
        <tr id="polyline-isempty">
            <td><code><b>isEmpty</b>()</code></td>
            <td><code>Boolean</code></td>
            <td>Возвращает <code>true</code>, если у Polyline нет точек LatLngs.</td>
        </tr>
        <tr id="polyline-getcenter">
            <td><code><b>getCenter</b>()</code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Возвращает центр (<a href="http://en.wikipedia.org/wiki/Centroid">centroid</a>) ломаной.</td>
        </tr>
        <tr id="polyline-getbounds">
            <td><code><b>getBounds</b>()</code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlngbounds">LatLngBounds</a></code></td>
            <td>Возвращает границы ломаной.</td>
        </tr>
        <tr id="polyline-addlatlng">
            <td><code><b>addLatLng</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i>)</nobr>
                <nobr>&lt;LatLng[]&gt; <i>latlngs?</i></nobr>,
            </code></td>
            <td><code>this</code></td>
            <td>Добавляет точку в ломаную. По умолчанию, добавляет точку в первое звено
                списка ломаных в случае мультиломаной. Это поведение может быть переопределено передачей
                определенного звена, как массива элементов LatLng (к которому вы могли получить
                доступ ранее, с помощью метода <a href="#polyline-getlatlngs">getlatlngs</a>).</td>
        </tr>
    </tbody>
</table>

Методы, унаследованные от <a href="#dgpath-methods">Path</a> <!-- TODO: include methods -->

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.Polygon

Класс для отрисовки многоугольников на карте. Расширяет <a href="#dgpolyline">Polyline</a>.

Обратите внимание на то, что среди точек, которые передаются для создания многоугольника, не должно быть
дополнительной точки, совпадающей с первой - такие точки лучше предварительно отфильтровать.

#### Пример использования

    // создает красный многоугольник из массива точек LatLng
    var latlngs = [[-111.03, 41],[-111.04, 45],[-104.05, 45],[-104.05, 41]];
    var polygon = DG.polygon(latlngs, {color: 'red'}).addTo(map);

    // увеличивает масштаб карты до максимального значения, при котором виден весь многоугольник
    map.fitBounds(polygon.getBounds());

Возможно также создать многоугольник с дырами, передав массив массивов latlngs,
первый latlngs массив отвечает за внешние границы, остальные описывают области внутри.

    var latlngs = [
      [[-111.03, 41],[-111.04, 45],[-104.05, 45],[-104.05, 41]], // внешняя граница
      [[-108.58,37.29],[-108.58,40.71],[-102.50,40.71],[-102.50,37.29]] // дыра
    ];

Также, вы можете передать многомерный массив, который представляет собой мульти-многоугольник (MultiPolygon).

    var latlngs = [
      [ // первый многоугольник
        [[-111.03, 41],[-111.04, 45],[-104.05, 45],[-104.05, 41]], // внешняя граница
        [[-108.58,37.29],[-108.58,40.71],[-102.50,40.71],[-102.50,37.29]] // дыра
      ],
      [ // второй многоугольник
        [[-109.05, 37],[-109.03, 41],[-102.05, 41],[-102.04, 37],[-109.05, 38]]
      ]
    ];

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="polygon-dg-polygon">
            <td><code>
                <b>DG.polygon</b>(
                <nobr>&lt;LatLng[]&gt; <i>latlngs</i></nobr>,
                <nobr>&lt;Polyline options&gt; <i>options?</i>)</nobr>
            </code></td>
            <td></td>
        </tr>
    </tbody>
</table>


#### Опции

Опции, унаследованные от <a href="#dgpolyline-options">Polyline</a> <!-- TODO: include options -->

Опции, унаследованные от <a href="#dgpath-options">Path</a> <!-- TODO: include options -->

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапов, унаследованные <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

<span id="#dgpolygon-methods"></span>

Методы, унаследованные от <a href="#dgpolyline-methods">Polyline</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="#dgpath-methods">Path</a> <!-- TODO: include methods -->

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.Rectangle

Класс для отрисовки прямоугольников на карте. Расширяет <a href="#dgpolygon">Polygon</a>.

#### Пример использования

    // создаем географические границы прямоугольника
    var bounds = [[54.559322, -5.767822], [56.1210604, -3.021240]];

    // создаем оранжевый прямоугольник
    DG.rectangle(bounds, {color: "#ff7800", weight: 1}).addTo(map);

    // подстраиваем центр карты и масштаб так, чтобы прямоугольник было видно
    map.fitBounds(bounds);

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="rectangle-dg-rectangle">
            <td><code>
                <b>DG.rectangle</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>latLngBounds</i></nobr>,
                <nobr>&lt;Polyline options&gt; <i>options?</i>)</nobr>
            </code></td>
            <td></td>
        </tr>
    </tbody>
</table>

#### Опции

Опции, унаследованные от <a href="#dgpolyline-options">Polyline</a> <!-- TODO: include options -->

Опции, унаследованные от <a href="#dgpath-options">Path</a> <!-- TODO: include options -->

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапов, унаследованные <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="rectangle-setbounds">
            <td><code><b>setBounds</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlngbounds">LatLngBounds</a>&gt; <i>latLngBounds</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Перерисовывает прямоугольник с новыми границами.</td>
        </tr>
    </tbody>
</table>


Методы, унаследованные от <a href="#dgpolygon-method">Polygon</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="#dgpath-methods">Path</a> <!-- TODO: include methods -->

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.Circle

Класс для отрисовки окружности на карте. Расширяет <a href="#dgpath">Path</a>. Это аппроксимация, которая начинает
отличаться от настоящей окружности ближе к полюсам (из-за искажений проекции).

#### Пример использование

    DG.circle([50.5, 30.5], 200).addTo(map);

#### Создние

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circle-dg-circle">
            <td><code>
                <b>DG.circle</b>(
                    <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                    <nobr>&lt;<a href="#dgpath-options">Path options</a>&gt; <i>options?</i>)</nobr>
            </code></td>
            <td>Создает объект круга по переданной географической точке и
                объекту опций, в котором содежится радиус круга.</td>
        </tr>
        <tr id="circle-dg-circle-2">
            <td><code><b>DG.circle</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                <nobr>&lt;Number&gt; <i>radius</i></nobr>,
                <nobr>&lt;<a href="#dgpath-options">Path options</a>&gt; <i>options?</i>)</nobr>
            </code></td>
            <td>Устаревший способ создания круга, только для совместимости со старым кодом.
                Не используйте его в своих новых приложениях и плагинах.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circle-radius">
            <td><code><b>radius</b></code></td>
            <td><code>Number</code>
            <td><code></code></td>
            <td>Радиус круга в метрах.</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="#dgpath-options">Path</a> <!-- TODO: include options -->

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапов, унаследованные <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

<table>
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circle-setradius">
            <td><code>
                <b>setRadius</b>(
                <nobr>&lt;Number&gt; <i>radius</i>)</nobr>
            </code></td>
            <td><code>this</code></td>
            <td>Устанавливает радиус окружности в метрах</td>
        </tr>
        <tr id="circle-getradius">
            <td><code><b>getRadius</b>()</code></td>
            <td><code>Number</code></td>
            <td>Возвращает текущий радиус окружности в метрах</td>
        </tr>
        <tr id="circle-getbounds">
            <td><code><b>getBounds</b>()</code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlngbounds">LatLngBounds</a></code></td>
            <td>Возвращает <a href="/doc/maps/ru/manual/basic-types#dglatlngbounds"><code>LatLngBounds</code></a>
                объекта.</td>
        </tr>
    </tbody>
</table>

Методы, унаследованные от <a href="#dgcirclemarker-methods">CircleMarker</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="#dgpath-methods">Path</a> <!-- TODO: include methods -->

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.CircleMarker

Окружность фиксированного размера с радиусом указанным в пикселях. Расширяет <a href="#класс-dgpath">Path</a>.

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circlemarker-dg-circlemarker">
            <td><code>
                <b>DG.circleMarker</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latlng</i></nobr>,
                <i>options</i>)</code></td>
            <td>Создает объект круглого маркера по переданной географической точке и необязательному объекту опций.</td>
        </tr>
    </tbody>
</table>

#### Опции

<table>
    <thead>
        <tr>
            <th>Опция</th>
            <th>Тип</th>
            <th>По умолчанию</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circlemarker-radius">
            <td><code><b>radius</b></code></td>
            <td><code>Number </code></td>
            <td><code>10</code></td>
            <td>Радиус маркера в пикселях</td>
        </tr>
    </tbody>
</table>

Опции, унаследованные от <a href="#dgpath-options">Path</a> <!-- TODO: include options -->

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

<table id="dgcirclemarker-methods">
    <thead>
        <tr>
            <th>Метод</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="circlemarker-togeojson">
            <td><code><b>toGeoJSON</b>()</code></td>
            <td><code>Object</code></td>
            <td>Возвращает <a href="http://en.wikipedia.org/wiki/GeoJSON">GeoJSON</a> представление круглого маркера
                (GeoJSON Point).</td>
        </tr>
        <tr id="circlemarker-setlatlng">
            <td><code><b>setLatLng</b>(
                <nobr>&lt;<a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a>&gt; <i>latLng</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Устанавливает географическую позицию круглого маркера.</td>
        </tr>
        <tr id="circlemarker-getlatlng">
            <td><code><b>getLatLng</b>()</code></td>
            <td><code><a href="/doc/maps/ru/manual/basic-types#dglatlng">LatLng</a></code></td>
            <td>Возвращает текущую географическую позицию круглого маркера.</td>
        </tr>
        <tr id="circlemarker-setradius">
            <td><code><b>setRadius</b>(<nobr>&lt;Number&gt; <i>radius</i>)</nobr></code></td>
            <td><code>this</code></td>
            <td>Устанавливает радиус окружности, значение в пикселях.</td>
        </tr>
        <tr id="circlemarker-getradius">
            <td><code><b>getRadius</b>()</code></td>
            <td><code>Number</code></td>
            <td>Возвращает текущее значение радиуса окружности.</td>
        </tr>
    </tbody>
</table>

Методы, унаследованные от <a href="#dgpath-methods">Path</a> <!-- TODO: include methods -->

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

### DG.Svg

Данный класс позволяет отображать векторные слои с помощью <a href="https://developer.mozilla.org/docs/Web/SVG">SVG</a>.
Наследуется от <a href="/doc/maps/ru/manual/base-classes#dgrenderer">Renderer</a>.

Из-за <a href="http://caniuse.com/#search=svg">технических ограничений</a>, SVG доступен не во всех браузерах
(например, Android версий 2.x и 3.x не поддерживает SVG).

SVG не доступен в IE8, но в этом браузере есть поддержка устаревшей технологии
<a href="https://en.wikipedia.org/wiki/Vector_Markup_Language">VML</a>, и SVG renderer переключится на использование
VML, в случае работы под IE8. Поддержка VML в библиотеке существует только для обратной совместимости со старой версией
Internet Explorer.

#### Пример использования

Использование SVG по умолчанию для всех векторных объектов на карте:

    var map = DG.map("map", {
        renderer: DG.svg();
    });

Использование SVG rendrer с дополнительными отступами для определенных векторных объектов:

    var map = DG.map("map");
    var myRenderer = DG.svg({ padding: 0.5 });
    var line = DG.polyline( coordinates, { renderer: myRenderer } );
    var circle = DG.circle( center, { renderer: myRenderer } );

#### Создание

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="svg-dg-svg">
            <td><code><b>DG.svg</b>(<nobr>&lt;SVG options&gt; <i>options?</i>)</nobr></code></td>
            <td>Создает SVG renderer, используя указанные опции.</td>
        </tr>
    </tbody>
</table>

#### Опции

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgrenderer-options">Renderer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->

#### Функции

Есть несколько статических функций, которые могут быть вызваны без создания объекта DG.SVG:

<table>
    <thead>
        <tr>
            <th>Функция</th>
            <th>Возвращает</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="svg-create">
            <td><code><b>create</b>(<nobr>&lt;String&gt; <i>name</i>)</nobr></code></td>
            <td><code>SVGElement</code></td>
            <td>Возвращает экземпляр <a href="https://developer.mozilla.org/docs/Web/API/SVGElement">SVGElement</a>,
                соответствуйщий имени класса, переданному как аргумент. Например, использование &#39;line&#39; вернет
                экземпляр <a href="https://developer.mozilla.org/docs/Web/API/SVGLineElement">SVGLineElement</a>.</td>
        </tr>
        <tr id="svg-pointstopath">
            <td><code>
                <b>pointsToPath</b>(
                <nobr>&lt;[]&gt; <i>rings</i>,</nobr>
                <nobr>&lt;Boolean&gt; <i>closed</i>)</nobr>
            </code></td>
            <td><code>String</code></td>
            <td>Генерирует строку SVG path для множества звеньев, каждое звено превращается
                в &quot;M..L..L..&quot;-инструкции </td>
        </tr>
    </tbody>
</table>

### DG.Canvas

Позволяет отрисовывать векторные слои с помощью <a href="https://developer.mozilla.org/docs/Web/API/Canvas_API">canvas</a>.
Наследуется от <a href="/doc/maps/ru/manual/base-classes#dgrenderer">Renderer</a>.
В виду <a href="http://caniuse.com/#search=canvas">технических ограничений</a>, Canvas доступен
не во всех браузерах (например, в IE8) и пересекающиеся объекты могут отображаться некорректно,
в некоторых крайних случаях.

#### Пример использована

Использование Canvas по умолчанию для всех векторных объектов на карте:

    var map = DG.map('map', {
        renderer: DG.canvas();
    });

Использование Canvas с дополнительными отступами, для определенных векторных объектов:

    var map = DG.map('map');
    var myRenderer = DG.canvas({ padding: 0.5 });
    var line = DG.polyline( coordinates, { renderer: myRenderer } );
    var circle = DG.circle( center, { renderer: myRenderer } );

#### Создание Canvas

<table>
    <thead>
        <tr>
            <th>Конструктор</th>
            <th>Описание</th>
        </tr>
	</thead>
    <tbody>
        <tr id="canvas-dg-canvas">
            <td><code><b>DG.canvas</b>(<nobr>&lt;Canvas options&gt; <i>options?</i>)</nobr></code></td>
            <td>Создает Canvas renderer, используя переданные опции.</td>
        </tr>
    </tbody>
</table>

#### Опции

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgrenderer-options">Renderer</a> <!-- TODO: include options -->

Опции, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-options">Layer</a> <!-- TODO: include options -->

#### События

События, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-events">Layer</a> <!-- TODO: include events -->

События попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-events">Layer</a> <!-- TODO: include popup events -->

#### Методы

Методы попапа, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-popup-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dglayer-methods">Layer</a> <!-- TODO: include methods -->

Методы, унаследованные от <a href="/doc/maps/ru/manual/base-classes#dgevented-methods">Evented</a> <!-- TODO: include methods -->


================================================
FILE: src/doc/ru/quickstart/quickstart.md
================================================
## Все возможности API&SDK 2ГИС
[dev.2gis.ru](https://dev.2gis.ru)

## Полная обновлённая документация
[docs.2gis.com/ru](https://docs.2gis.com/ru)



## Общие сведения

При помощи API карт вы сможете:

* <span style="color:323232">создавать интерактивные карты на веб-странице;</span>
* <span style="color:323232">показывать на карте различные объекты (маркеры, попапы, геометрические объекты);</span>
* <span style="color:323232">производить поиск на карте: определять координаты геообъектов по их названиям и названия по координатам.</span>

Исходный код API карт доступен на [GitHub](https://github.com/2gis/mapsapi), проект открыт к предложениям и пулл-реквестам.

### Начало работы

Ниже приведен простой пример создания карты.

#### Подключите API

Для подключения JavaScript кода API добавьте в секцию head HTML-страницы следующий код:

    <script src="https://maps.api.2gis.ru/2.0/loader.js?pkg=full"></script>

Если вас интересует подключение кода API с помощью npm, перейдите в раздел [Подключение API](/doc/maps/ru/manual/dg-loading#npm).

#### Создайте контейнер карты

Для создания контейнера, в котором будет отображаться карта, необходимо добавить блочный HTML-элемент необходимого вам размера:

    <body>
        <div id="map" style="width:500px; height:400px"></div>
    </body>

#### Создайте карту

Теперь все готово к тому, чтобы создать карту. Для этого добавьте следующий код в секцию head:

    <script type="text/javascript">
        var map;

        DG.then(function () {
            map = DG.map('map', {
                center: [54.98, 82.89],
                zoom: 13
            });
        });
    </script>

В данном примере карта принимает два параметра:

* <span style="color:323232">center - координаты центра карты в формате [широта, долгота];</span>
* <span style="color:323232">zoom - коэффициент масштабирования в диапазоне от 1 до 18.</span>

#### Добавьте маркер на карту

После создания карты вы можете отобразить на ней маркер, добавив одну строку кода в написанный ранее код:

    <script type="text/javascript">
        var map;

        DG.then(function () {
            map = DG.map('map', {
                center: [54.98, 82.89],
                zoom: 13
            });

            DG.marker([54.98, 82.89]).addTo(map);
        });
    </script>

#### Покажите попап с информацией

Если немного расширить добавленную выше строку кода с маркером, тогда при клике в маркер будет отображаться попап
(всплывающий блок) с необходимой вам информацией:

    <script type="text/javascript">
        var map;

        DG.then(function () {
            map = DG.map('map', {
                center: [54.98, 82.89],
                zoom: 13
            });

            DG.marker([54.98, 82.89]).addTo(map).bindPopup('Вы кликнули по мне!');
        });
    </script>

#### Всё вместе

Результирующий код:

    <!DOCTYPE html>
    <html>
        <head>
            <title>API карт 2ГИС</title>
            <script src="https://maps.api.2gis.ru/2.0/loader.js?pkg=full"></script>
            <script type="text/javascript">
                var map;

                DG.then(function () {
                    map = DG.map('map', {
                        center: [54.98, 82.89],
                        zoom: 13
                    });

                    DG.marker([54.98, 82.89]).addTo(map).bindPopup('Вы кликнули по мне!');
                });
            </script>
        </head>
        <body>
            <div id="map" style="width:500px; height:400px"></div>
        </body>
    </html>

### Дальнейшие шаги

Всё получилось? Теперь можно ознакомиться с <a href="/doc/maps/ru/manual/dg-loading">руководством для разработчиков</a>
и <a href="/doc/maps/ru/examples/base">примерами использования</a>.

### Техническая поддержка

Если у вас возникли сложности в работе с API карт &mdash; <a href="mailto:api@2gis.ru">напишите нам письмо</a>
и мы обязательно поможем вам разобраться.

### Порядок определения стоимости

Порядок определения стоимости программного обеспечения вы можете найти по адресу https://docs.2gis.com/ru/prices.


================================================
FILE: src/less/images-usage-statistics.less
================================================
stats {
    .repeatableBg;
    .notRepeatableBg;
    repeatable: '@{repeatableBgNames}';
    notRepeatableSprited: '@{notRepeatableBgNamesSprited}';
    notRepeatableNotSprited: '@{notRepeatableBgNamesNotSprited}';
}


================================================
FILE: src/less/mixins.ie8.less
================================================
.opacity(@value) when (isnumber(@value)) and (@value < 1) {
    @percentValue: @value * 100;

    -ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=@{percentValue})";
    filter: e("alpha(opacity=@{percentValue})");
}

.gradient(@from; @to; @type: 0) when (iscolor(@from)) and (iscolor(@to)) {
    @argbFrom: argb(@from);
    @argbTo: argb(@to);

    filter: e("progid:DXImageTransform.Microsoft.gradient(GradientType=@{type},startColorstr='@{argbFrom}',endColorstr='@{argbTo}')");
}

.alphaImage(@name; @sizingMethod: scale) {
    filter: e("progid:DXImageTransform.Microsoft.AlphaImageLoader(src='@{spritesURL}/img/@{name}.png',sizingMethod='@{sizingMethod}')");
}


================================================
FILE: src/less/mixins.images-usage-statistics.less
================================================
@addToRepeatables: ~`addToRepeatables =
    (function () {
        var names = '';
        return function (name) {
            if (typeof name == 'string' && name.length) {
                names = names + (names.length ? ',' : '') + name;
            }

            return names;
        }
    })()`;

.repeatableBg(@name: '') {
    @repeatableBgNames: ~`addToRepeatables(@{name})`;
}

@addToNotRepeatablesSprited: ~`addToNotRepeatablesSprited =
    (function () {
        var names = '';
        return function (name) {
            if (typeof name == 'string' && name.length) {
                names = names + (names.length ? ',' : '') + name;
            }

            return names;
        }
    })()`;

@addToNotRepeatablesNotSprited: ~`addToNotRepeatablesNotSprited =
    (function () {
        var names = '';
        return function (name) {
            if (typeof name == 'string' && name.length) {
                names = names + (names.length ? ',' : '') + name;
            }

            return names;
        }
    })()`;

.notRepeatableBg(@name: ''; @newerNotUseSprite: false) {
    @notRepeatableBgNamesSprited: ~`addToNotRepeatablesSprited()`;
    @notRepeatableBgNamesNotSprited: ~`addToNotRepeatablesNotSprited()`;

    & when not (@newerNotUseSprite) {
        @notRepeatableBgNamesSprited: ~`addToNotRepeatablesSprited(@{name})`;
    }
    & when (@newerNotUseSprite) {
        @notRepeatableBgNamesNotSprited: ~`addToNotRepeatablesNotSprited(@{name})`;
    }
}

.notRepeatableBgWithSizes(@name; @newerNotUseSprite: false) {
    .notRepeatableBg(@name: ''; @newerNotUseSprite: false);
}

.alphaImage(@name: '') {
    @notRepeatableBgNamesNotSprited: ~`addToNotRepeatablesNotSprited(@{name})`;
}


================================================
FILE: src/less/mixins.less
================================================
/*
    Variables:
        @baseURL
        @ie8
        @skinName
        @imagesBasePath

    Mixins:
        .imageData
        .spriteData
        .isSprited
*/

.imageData(@name) when (default()) {
    @filename: '';
    @extension: '';
    @hasVectorVersion: false;
    @width: 0;
    @height: 0;
    @originalWidth: 0;
    @originalHeight: 0;
}

.isSprited(@name) when (default()) {
    @isSprited: false;
}

.dataURIImage(@name) {
    .imageData(@name);

    & when (@hasVectorVersion) {
        background-image: data-uri('@{imagesBasePath}/@{filename}.svg');
    }

    & when not (@hasVectorVersion) {
        background-image: data-uri('@{imagesBasePath}/@{filename}.@{extension}');
    }
}

.directImage(@name) {
    .imageData(@name);

    background-image: url('@{baseURL}/img/@{filename}.@{extension}');
    background-size: @originalWidth @originalHeight;

    .leaflet-retina & when not (@extension = 'gif') {
        background-image: url('@{baseURL}/img/@{filename}@2x.@{extension}');
    }
}

.spriteImage(@name) {
    .spriteData(@name);

    width: @width;
    height: @height;
    background-image: url('@{baseURL}/img/@{backgroundImage}');
    background-position: @backgroundPosition;
    background-size: @totalWidth @totalHeight;

    .leaflet-retina & {
        .spriteData('@{name}@2x');
        background-image: url('@{baseURL}/img/@{backgroundImage}');
        // Spritesmith при формировании 2x-спрайтов часто располагает изображения в другой последовательности,
        // поэтому размеры проставляем заново, определённые выше скорей всего не подходят.
        background-position: @backgroundPositionLeft / 2 @backgroundPositionTop / 2;
        background-size: @totalWidth / 2 @totalHeight / 2;
    }
}

.repeatableBg(@name) {
    .imageData(@name);

    & when not (@ie8) and (@hasVectorVersion) {
        .dataURIImage(@name);
    }

    & when (@ie8), not (@hasVectorVersion) {
        .directImage(@name);
    }
}

.notRepeatableBg(@name; @newerNotUseSprite: false) {
    background-repeat: no-repeat;

    .imageData(@name);

    & when not (@ie8) and (@hasVectorVersion) {
        .dataURIImage(@name);
    }

    & when (@ie8), not (@hasVectorVersion) {
        .isSprited(@name);

        & when (@isSprited) and not (@newerNotUseSprite) {
            .spriteImage(@name);
        }

        & when not (@isSprited), (@newerNotUseSprite) {
            .directImage(@name);
        }
    }
}

.notRepeatableBgWithSizes(@name; @newerNotUseSprite: false) {
    .imageData(@name);
    .isSprited(@name);
    .notRepeatableBg(@name, @newerNotUseSprite);

    & when not (@ie8) and (@hasVectorVersion) {
        width: @width;
        height: @height;
        background-size: @originalWidth @originalHeight;
    }

    & when (@ie8), not (@hasVectorVersion) {
        .isSprited(@name);

        & when not (@isSprited), (@newerNotUseSprite) {
            width: @width;
            height: @height;
        }
    }
}


================================================
FILE: src/menu.json
================================================
{
    "mapsapi": {
        "content": {
            "ru": {
                "title": "API карт",
                "uri": "maps/ru/quickstart",
                "_src":"ru/quickstart/quickstart.md",
                "hide": false
            },
            "en": {
                "title": "Maps API",
                "uri": "maps/en/quickstart",
                "_src":"en/quickstart/quickstart.md",
                "hide": false
            }
        },
        "children": [
            {
                "content": {
                    "ru": {
                        "title": "Быстрый старт",
                        "uri": "maps/ru/quickstart",
                        "_src":"ru/quickstart/quickstart.md",
                        "hide": false
                    },
                    "en": {
                        "title": "Quick Start",
                        "uri": "maps/en/quickstart",
                        "_src":"en/quickstart/quickstart.md",
                        "hide": false
                    }
                },
                "children": null
            },
            {
                "content": {
                    "ru": {
                        "title": "Руководство",
                        "uri": "maps/ru/manual/dg-loading",
                        "_src":"ru/manual/dg-loading.md",
                        "hide": false
                    },
                    "en": {
                        "title": "Manual",
                        "uri": "maps/en/manual/dg-loading",
                        "_src":"en/manual/dg-loading.md",
                        "hide": false
                    }
                },
                "children": [
                    {
                        "content": {
                            "ru": {
                                "title": "Подключение API",
                                "uri": "maps/ru/manual/dg-loading",
                                "_src":"ru/manual/dg-loading.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Loading API",
                                "uri": "maps/en/manual/dg-loading",
                                "_src":"en/manual/dg-loading.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Базовые типы",
                                "uri": "maps/ru/manual/basic-types",
                                "_src":"ru/manual/basic-types.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Basic Types",
                                "uri": "maps/en/manual/basic-types",
                                "_src":"en/manual/basic-types.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Базовые классы",
                                "uri": "maps/ru/manual/base-classes",
                                "_src":"ru/manual/base-classes.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Base Classes",
                                "uri": "maps/en/manual/base-classes",
                                "_src":"en/manual/base-classes.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Карта",
                                "uri": "maps/ru/manual/map",
                                "_src":"ru/manual/map.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Map",
                                "uri": "maps/en/manual/map",
                                "_src":"en/manual/map.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Маркеры",
                                "uri": "maps/ru/manual/markers",
                                "_src":"ru/manual/markers.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Markers",
                                "uri": "maps/en/manual/markers",
                                "_src":"en/manual/markers.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Попапы",
                                "uri": "maps/ru/manual/popup",
                                "_src":"ru/manual/popup.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Popups",
                                "uri": "maps/en/manual/popup",
                                "_src":"en/manual/popup.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Подсказки",
                                "uri": "maps/ru/manual/dg-label",
                                "_src":"ru/manual/dg-label.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Labels",
                                "uri": "maps/en/manual/dg-label",
                                "_src":"en/manual/dg-label.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Элементы управления",
                                "uri": "maps/ru/manual/controls",
                                "_src":"ru/manual/controls.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Controls",
                                "uri": "maps/en/manual/controls",
                                "_src":"en/manual/controls.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Векторные слои",
                                "uri": "maps/ru/manual/vector-layers",
                                "_src":"ru/manual/vector-layers.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Vector Layers",
                                "uri": "maps/en/manual/vector-layers",
                                "_src":"en/manual/vector-layers.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Растровые слои",
                                "uri": "maps/ru/manual/raster-layers",
                                "_src":"ru/manual/raster-layers.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Raster Layers",
                                "uri": "maps/en/manual/raster-layers",
                                "_src":"en/manual/raster-layers.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Прочие слои",
                                "uri": "maps/ru/manual/other-layers",
                                "_src":"ru/manual/other-layers.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Other Layers",
                                "uri": "maps/en/manual/other-layers",
                                "_src":"en/manual/other-layers.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Внешние модули",
                                "uri": "maps/ru/manual/dg-external-modules",
                                "_src":"ru/manual/dg-external-modules.md",
                                "hide": false
                            },
                            "en": {
                                "title": "External Modules",
                                "uri": "maps/en/manual/dg-external-modules",
                                "_src":"en/manual/dg-external-modules.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Линейка",
                                "uri": "maps/ru/manual/dg-ruler",
                                "_src":"ru/manual/dg-ruler.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Ruler",
                                "uri": "maps/en/manual/dg-ruler",
                                "_src":"en/manual/dg-ruler.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Метаслои",
                                "uri": "maps/ru/manual/dg-metalayers",
                                "_src":"ru/manual/dg-metalayers.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Meta Layers",
                                "uri": "maps/en/manual/dg-metalayers",
                                "_src":"en/manual/dg-metalayers.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Слой пробок",
                                "uri": "maps/ru/manual/dg-traffic",
                                "_src":"ru/manual/dg-traffic.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Traffic",
                                "uri": "maps/en/manual/dg-traffic",
                                "_src":"en/manual/dg-traffic.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Входы в здания",
                                "uri": "maps/ru/manual/dg-entrance",
                                "_src":"ru/manual/dg-entrance.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Entrances",
                                "uri": "maps/en/manual/dg-entrance",
                                "_src":"en/manual/dg-entrance.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Определение проекта",
                                "uri": "maps/ru/manual/dg-project-detector",
                                "_src":"ru/manual/dg-project-detector.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Project Detector",
                                "uri": "maps/en/manual/dg-project-detector",
                                "_src":"en/manual/dg-project-detector.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Асинхронные запросы",
                                "uri": "maps/ru/manual/dg-ajax",
                                "_src":"ru/manual/dg-ajax.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Asynchronous Requests",
                                "uri": "maps/en/manual/dg-ajax",
                                "_src":"en/manual/dg-ajax.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "WKT-формат",
                                "uri": "maps/ru/manual/dg-wkt",
                                "_src":"ru/manual/dg-wkt.md",
                                "hide": false
                            },
                            "en": {
                                "title": "WKT",
                                "uri": "maps/en/manual/dg-wkt",
                                "_src":"en/manual/dg-wkt.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Локализация",
                                "uri": "maps/ru/manual/dg-locale",
                                "_src":"ru/manual/dg-locale.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Localization",
                                "uri": "maps/en/manual/dg-locale",
                                "_src":"en/manual/dg-locale.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Вспомогательные классы",
                                "uri": "maps/ru/manual/utils",
                                "_src":"ru/manual/utils.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Utility",
                                "uri": "maps/en/manual/utils",
                                "_src":"en/manual/utils.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Работа с DOM",
                                "uri": "maps/ru/manual/dom-utils",
                                "_src":"ru/manual/dom-utils.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Working with DOM",
                                "uri": "maps/en/manual/dom-utils",
                                "_src":"en/manual/dom-utils.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Переход на версию 2.0",
                                "uri": "maps/ru/manual/dg-migration",
                                "_src":"ru/manual/dg-migration.md",
                                "hide": false
                            }
                        },
                        "children": null
                    }
                ]
            },
            {
                "content": {
                    "ru": {
                        "title": "Примеры",
                        "uri": "maps/ru/examples/base",
                        "_src":"ru/examples/base.md",
                        "hide": false
                    },
                    "en": {
                        "title": "Examples",
                        "uri": "maps/en/examples/base",
                        "_src":"en/examples/base.md",
                        "hide": false
                    }
                },
                "children": [
                    {
                        "content": {
                            "ru": {
                                "title": "Базовое использование",
                                "uri": "maps/ru/examples/base",
                                "_src":"ru/examples/base.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Basic Usage",
                                "uri": "maps/en/examples/base",
                                "_src":"en/examples/base.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Работа с маркерами",
                                "uri": "maps/ru/examples/markers",
                                "_src":"ru/examples/markers.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Work with Markers",
                                "uri": "maps/en/examples/markers",
                                "_src":"en/examples/markers.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Работа с попапами",
                                "uri": "maps/ru/examples/popups",
                                "_src":"ru/examples/popups.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Work with Popups",
                                "uri": "maps/en/examples/popups",
                                "_src":"en/examples/popups.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Работа с границами",
                                "uri": "maps/ru/examples/bounds",
                                "_src":"ru/examples/bounds.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Work with Map Bounds",
                                "uri": "maps/en/examples/bounds",
                                "_src":"en/examples/bounds.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Работа с векторными слоями",
                                "uri": "maps/ru/examples/vector-layers",
                                "_src":"ru/examples/vector-layers.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Work with Vector Layers",
                                "uri": "maps/en/examples/vector-layers",
                                "_src":"en/examples/vector-layers.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Элементы управления",
                                "uri": "maps/ru/examples/controls",
                                "_src":"ru/examples/controls.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Control Elements",
                                "uri": "maps/en/examples/controls",
                                "_src":"en/examples/controls.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Работа с GeoJSON",
                                "uri": "maps/ru/examples/geojson",
                                "_src":"ru/examples/geojson.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Work with GeoJSON",
                                "uri": "maps/en/examples/geojson",
                                "_src":"en/examples/geojson.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Работа с WKT",
                                "uri": "maps/ru/examples/wkt",
                                "_src":"ru/examples/wkt.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Work with WKT",
                                "uri": "maps/en/examples/wkt",
                                "_src":"en/examples/wkt.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Обработка событий",
                                "uri": "maps/ru/examples/events",
                                "_src":"ru/examples/events.md",
                                "hide": false
                            },
                            "en": {
                                "title": "Processing of Events",
                                "uri": "maps/en/examples/events",
                                "_src":"en/examples/events.md",
                                "hide": false
                            }
                        },
                        "children": null
                    },
                    {
                        "content": {
                            "ru": {
                                "title": "Внешние модули",
                                "uri": "maps/ru/examples/external-modules",
                                "_src":"ru/examples/external-modules.md",
                                "hide": false
                            },
                            "en": {
                                "title": "External Modules",
                                "uri": "maps/en/examples/external-modules",
                                "_src":"en/examples/external-modules.md",
                                "hide": false
                            }
                        },
                        "children": null
                    }
                ]
            }
        ]
    }
}


================================================
FILE: test/after.js
================================================
// this script will be run after loading js, but before starting tests
DG.Map.mergeOptions({
    tilesCheck: false
});

// Add function for remove all layers on map. Need for tests of leaflet, because we have our layers.
DG.Map.include({
    'clearLayers': function() {
        this.eachLayer(function(layer) {
            this.removeLayer(layer);
        }, this);
    }
});


================================================
FILE: test/excludedTests.js
================================================
// excluded, because L.DG.TileLayer added to the map by default,
// but leaflet tests think that map without layers and fails
module.exports = [
    'node_modules/leaflet/spec/suites/core/UtilSpec.js',
    'node_modules/leaflet/spec/suites/map/MapSpec.js',
    'node_modules/leaflet/spec/suites/map/handler/Map.DragSpec.js',
    'node_modules/leaflet/spec/suites/layer/tile/GridLayerSpec.js',
    'node_modules/leaflet/spec/suites/layer/PopupSpec.js',
    'node_modules/leaflet/spec/suites/layer/vector/CanvasSpec.js',
    'node_modules/leaflet/spec/suites/layer/marker/Icon.DefaultSpec.js',
    'node_modules/leaflet/spec/suites/layer/TooltipSpec.js',
    'node_modules/leaflet/spec/suites/layer/vector/PathSpec.js'
];


================================================
FILE: test/karma.conf.js
================================================
require('dotenv').config();
module.exports = function(config) {
    config.set({
        basePath: '../',

        frameworks: ['mocha', 'expect', 'sinon'],

        client: {
            captureConsole: true,
            mocha: {
                timeout: 480000
            },
            secretKey: process.env.TEST_SECRET_KEY || '',
            secretInvalidKey: process.env.TEST_REACHED_LIMITS_SECRET_KEY  || ''
        },

        // use dots reporter, as travis terminal does not support escaping sequences
        // possible values: 'dots', 'progress', 'junit', 'teamcity'
        // CLI --reporters progress
        reporters: ['dots', 'coverage'],

        coverageReporter: {
            type : 'lcov',
            dir : 'coverage/',
            subdir: '.'
        },

        // web server port
        // CLI --port 9876
        port: 9876,

        // cli runner port
        // CLI --runner-port 9100
        runnerPort: 9100,

        // enable / disable colors in the output (reporters and logs)
        // CLI --colors --no-colors
        colors: true,

        // level of logging
        // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
        // CLI --log-level debug
        logLevel: config.LOG_ERROR,

        // enable / disable watching file and executing test whenever any file changes
        // CLI --auto-watch --no-auto-watch
        autoWatch: true,

        // Start these browsers, currently available:
        // - Chrome
        // - ChromeCanary
        // - Firefox
        // - Opera
        // - Safari (only Mac)
        // - PhantomJS
        // - IE (only Windows)
        // CLI --browsers Chrome,Firefox,Safari
        browsers: ['PhantomJS'],

        // If browser does not capture in given timeout [ms], kill it
        // CLI --capture-timeout 5000
        captureTimeout: 480000,
        browserNoActivityTimeout: 480000,

        // Auto run test on start (when browsers are captured) and exit
        // CLI --single-run --no-single-run
        singleRun: false,

        // report which specs are slower than 500ms
        // CLI --report-slower-than 1000
        reportSlowerThan: 1000,

        plugins: [
            'karma-mocha',
            'karma-expect',
            'karma-sinon',
            'karma-phantomjs-launcher',
            'karma-chrome-launcher',
            'karma-opera-launcher',
            'karma-firefox-launcher',
            'karma-mocha-reporter',
            'karma-coverage'
        ]
    });
};


================================================
FILE: test/test.js
================================================
var argv = require('optimist').argv;

exports.getBrowsers = function() {
    var browsers = ['PhantomJS'];

    if (argv.hasOwnProperty('ff')) {
        browsers.push('Firefox');
    }
    if (argv.hasOwnProperty('chrome')) {
        browsers.push('Chrome');
    }
    if (argv.hasOwnProperty('opera')) {
        browsers.push('Opera');
    }
    if (argv.hasOwnProperty('safari')) {
        browsers.push('Safari');
    }
    if (argv.hasOwnProperty('ie')) {
        browsers.push('IE');
    }

    return browsers;
};

exports.getReporters = function(isDebug) {
    var reporters = isDebug ? ['mocha'] : ['dots'];

    reporters.push('coverage');

    if (argv.hasOwnProperty('reporters')) {
        reporters = argv.reporters.split(',');
    }

    return reporters;
};

exports.getJunitReporter = function() {
    var junitReporter = {};

    if (argv.hasOwnProperty('junitOutput')) {
        junitReporter['outputFile'] = argv.junitOutput;
    }

    return junitReporter;
};


================================================
FILE: vendors/baron/Gruntfile.js
================================================
module.exports = function (grunt) {

    grunt.initConfig({
        pkg: grunt.file.readJSON('package.json'),
        jshint: {
            appjs: {
                options: {
                    "indent": 4,
                    "node": true,
                    "browser": true,
                    "jquery": true,
                    "eqnull": true,
                    "eqeqeq": false,
                    "devel": false,
                    "boss": true,
                    "trailing": true,
                    "loopfunc": true,
                    "-W041": true,
                    "-W015": true,
                    "sub": true,
                    "unused": true
                },
                src: ['src/*.js', 'demo/*.js', 'test/*.js']
            }
        },
        concat: {
            def: {
                files: {
                    'dist/<%= pkg.name %>.js': ['src/core.js', 'src/fix.js', 'src/controls.js', 'src/pull.js'],
                    '<%= pkg.name %>.js': ['src/core.js', 'src/fix.js', 'src/controls.js', 'src/pull.js']
                }
            },
            core: {
                src: [
                    'src/core.js'
                ],
                dest: 'dist/<%= pkg.name %>.js'
            },
            full: {
                files: {
                    'dist/<%= pkg.name %>.js': ['src/core.js', 'src/fix.js', 'src/controls.js', 'src/test.js', 'src/pull.js'],
                    'demo/<%= pkg.name %>.full.js': ['src/core.js', 'src/fix.js', 'src/controls.js', 'src/test.js', 'src/pull.js']
                }
            }
        },
        uglify: {
            options: {
                banner: '/*! <%= pkg.name %> <%= grunt.template.today("dd-mm-yyyy") %> */\n'
            },
            def: {
                files: {
                    'dist/<%= pkg.name %>.min.js': ['dist/<%= pkg.name %>.js'],
                    '<%= pkg.name %>.min.js': ['<%= pkg.name %>.js']
                }
            },
            core: {
                files: {
                    'dist/<%= pkg.name %>.min.js': ['<%= concat.core.dest %>'],
                    '<%= pkg.name %>.min.js': ['<%= concat.core.dest %>']
                }
            },
            full: {
                files: {
                    'dist/<%= pkg.name %>.min.js': ['dist/<%= pkg.name %>.js'],
                    '<%= pkg.name %>.min.js': ['<%= pkg.name %>.js']
                }
            }
        },
        'mocha-phantomjs': {
            options: {
                view: '1024x768'
            },
            all: ['test/*.auto.html']
        }
    });

    grunt.loadTasks('tasks'); // Для grunt-mocha-phantomjs
    grunt.loadNpmTasks('grunt-contrib-jshint');
    grunt.loadNpmTasks('grunt-contrib-uglify');
    grunt.loadNpmTasks('grunt-contrib-concat');

    grunt.registerTask('default', ['concat:def', 'uglify:def']);
    grunt.registerTask('core', ['concat:core', 'uglify:core']);
    grunt.registerTask('full', ['concat:full', 'uglify:full']);
    grunt.registerTask('test', ['mocha-phantomjs']);
    grunt.registerTask('t', ['jshint', 'mocha-phantomjs']);
};

================================================
FILE: vendors/baron/baron.css
================================================
/* CSS styles in this file are need for proper Baron work */
.dg-wrapper {
    position: relative;
    overflow: hidden;
}
.dg-scroller {
    height: 100%;
    overflow-y: scroll;
    border: 0;
}
.dg-scroller::-webkit-scrollbar { /* Preventing webkit bug of horizontal scrolling */
    width: 0;
}
.dg-scroller__bar { /* The bar. You should define width, right and background */
    position: absolute;    
    z-index: 1;
    right: 0;
    width: 10px;
    background: #999;
}
.dg-scroller__bar_h {
    bottom: 2px;
    height: 8px;
}

.dg-header__title {
    width: 100%;
    margin: 0;
    -moz-box-sizing: border-box;
    box-sizing: border-box; /* For padding and border, if exist */
    background: #999;

    /* pointer-events: none; /* IE9+ https://developer.mozilla.org/en-US/docs/CSS/pointer-events */
}
.dg-header__title_state_fixed {
    position: absolute;
    z-index: 1; /* Removing flicker effect */
}


================================================
FILE: vendors/baron/baron.js
================================================
(function(window, undefined) {
    'use strict';

    if (!window) return; // Server side

var
    _baron = window.baron, // Stored baron value for noConflict usage
    $ = window.jQuery, // Trying to use jQuery
    origin = {
        v: { // Vertical
            x: 'Y', pos: 'top', crossPos: 'left', size: 'height', crossSize: 'width',
            client: 'clientHeight', crossClient: 'clientWidth', offset: 'offsetHeight', crossOffset: 'offsetWidth', offsetPos: 'offsetTop',
            scroll: 'scrollTop', scrollSize: 'scrollHeight'
        },
        h: { // Horizontal
            x: 'X', pos: 'left', crossPos: 'top', size: 'width', crossSize: 'height',
            client: 'clientWidth', crossClient: 'clientHeight', offset: 'offsetWidth', crossOffset: 'offsetHeight', offsetPos: 'offsetLeft',
            scroll: 'scrollLeft', scrollSize: 'scrollWidth'
        }
    },

    each = function(obj, iterator) {
        var i = 0;

        if (obj.length === undefined || obj === window) obj = [obj];

        while (obj[i]) {
            iterator.call(this, obj[i], i);
            i++;
        }
    },

    baron = function(params) { // this - window or jQuery instance
        var jQueryMode = false,//(this && this[0] && this[0].nodeType),
            roots,
            $;

        params = params || {};
        $ = params.$ || window.jQuery;

        if (jQueryMode) {
            params.root = roots = this;
        } else {
            roots = $(params.root || params.scroller);
        }

        return new baron.fn.constructor(roots, params, $);
    };

    baron.fn = {
        constructor: function(roots, input, $) {
            var params = validate(input);

            params.$ = $;
            each.call(this, roots, function(root, i) {
                var localParams = clone(params);

                if (params.root && params.scroller) {
                    localParams.scroller = params.$(params.scroller, root);
                    if (!localParams.scroller.length) {
                        localParams.scroller = root;
                    }
                } else {
                    localParams.scroller = root;
                }

                localParams.root = root;
                this[i] = init(localParams);
                this.length = i + 1;
            });

            this.params = params;
        },

        dispose: function() {
            var params = this.params;

            each(this, function(item) {
                item.dispose(params);
            });
            this.params = null;
        },

        update: function() {
            var i = 0;

            while (this[i]) {
                this[i].update.apply(this[i], arguments);
                i++;
            }
        },

        baron: function(params) {
            params.root = [];
            params.scroller = this.params.scroller;

            each.call(this, this, function(elem) {
                params.root.push(elem.root);
            });
            params.direction = (this.params.direction == 'v') ? 'h' : 'v';
            params._chain = true;

            return baron(params);
        }
    };

    function manageEvents(item, eventManager, mode) {
        item._eventHandlers = item._eventHandlers || [ // Creating new functions for one baron item only one time
            {
                // onScroll:
                element: item.scroller,

                handler: function(e) {
                    item.scroll(e);
                },

                type: 'scroll'
            }, {
                // onMouseDown:
                element: item.bar,

                handler: function(e) {
                    e.preventDefault ? e.preventDefault() : e.returnValue = false; // Text selection disabling in Opera... and all other browsers?
                    item.selection(); // Disable text selection in ie8
                    item.drag.now = 1; // Save private byte
                },

                type: 'touchstart mousedown'
            }, {
                // onMouseUp:
                element: document,

                handler: function() {
                    item.selection(1); // Enable text selection
                    item.drag.now = 0;
                },

                type: 'mouseup blur touchend'
            }, {
                // onCoordinateReset:
                element: item.bar,

                handler: function(e) {
                    if (e.button != 2) { // Not RM
                        item._pos0(e);
                    }
                },

                type: 'touchstart mousedown'
            }, {
                // onMouseMove:
                element: document,

                handler: function(e) {
                    if (item.drag.now) {
                        item.drag(e);
                    }
                },

                type: 'mousemove touchmove'
            }, {
                // onResize:
                element: window,

                handler: function() {
                    item.update();
                },

                type: 'resize'
            }, {
                // sizeChange:
                element: item.root,

                handler: function() {
                    item.update();
                },

                type: 'sizeChange'
            }
        ];

        each(item._eventHandlers, function(event) {
            if (event.element) {
                eventManager(event.element, event.type, event.handler, mode);
            }
        });

        // if (item.scroller) {
        //     event(item.scroller, 'scroll', item._eventHandlers.onScroll, mode);
        // }
        // if (item.bar) {
        //     event(item.bar, 'touchstart mousedown', item._eventHandlers.onMouseDown, mode);
        // }
        // event(document, 'mouseup blur touchend', item._eventHandlers.onMouseUp, mode);
        // event(document, 'touchstart mousedown', item._eventHandlers.onCoordinateReset, mode);
        // event(document, 'mousemove touchmove', item._eventHandlers.onMouseMove, mode);
        // event(window, 'resize', item._eventHandlers.onResize, mode);
        // if (item.root) {
        //     event(item.root, 'sizeChange', item._eventHandlers.onResize, mode); // Custon event for alternate baron update mechanism
        // }
    }

    function manageAttr(node, direction, mode) {
        var attrName = 'data-baron-' + direction;

        if (mode == 'on') {
            node.setAttribute(attrName, 'inited');
        } else if (mode == 'off') {
            node.removeAttribute(attrName);
        } else {
            return node.getAttribute(attrName);
        }
    }

    function init(params) {
        if (manageAttr(params.root, params.direction)) return;

        var out = new item.prototype.constructor(params); // __proto__ of returning object is baron.prototype

        manageEvents(out, params.event, 'on');

        manageAttr(out.root, params.direction, 'on');

        out.update();

        return out;
    }

    function clone(input) {
        var output = {};

        input = input || {};

        for (var key in input) {
            if (input.hasOwnProperty(key)) {
                output[key] = input[key];
            }
        }

        return output;
    }

    function validate(input) {
        var output = clone(input);

        output.direction = output.direction || 'v';

        var event = input.event || function(elem, event, func, mode) {
            output.$(elem)[mode || 'on'](event, func);
        };

        output.event = function(elems, e, func, mode) {
            each(elems, function(elem) {
                event(elem, e, func, mode);
            });
        };

        return output;
    }

    function fire(eventName) {
        /* jshint validthis:true */
        if (this.events && this.events[eventName]) {
            for (var i = 0 ; i < this.events[eventName].length ; i++) {
                var args = Array.prototype.slice.call( arguments, 1 );

                this.events[eventName][i].apply(this, args);
            }
        }
    }

    var item = {};

    item.prototype = {
        constructor: function(params) {
            var $,
                barPos,
                scrollerPos0,
                track,
                resizePauseTimer,
                scrollPauseTimer,
                pause,
                scrollLastFire,
                resizeLastFire;

            resizeLastFire = scrollLastFire = new Date().getTime();

            $ = this.$ = params.$;
            this.event = params.event;
            this.events = {};

            function getNode(sel, context) {
                return $(sel, context)[0]; // Can be undefined
            }

            // DOM elements
            this.root = params.root; // Always html node, not just selector
            this.scroller = getNode(params.scroller); // (params.scroller) ? getNode(params.scroller, this.root) : this.root;
            this.bar = getNode(params.bar, this.root);
            track = this.track = getNode(params.track, this.root);
            if (!this.track && this.bar) {
                track = this.bar.parentNode;
            }
            this.clipper = this.scroller.parentNode;

            // Parameters
            this.direction = params.direction;
            this.origin = origin[this.direction];
            this.barOnCls = params.barOnCls;
            this.barTopLimit = 0;
            pause = params.pause * 1000 || 0;

            // Updating height or width of bar
            function setBarSize(size) {
                /* jshint validthis:true */
                var barMinSize = this.barMinSize || 20;

                if (size > 0 && size < barMinSize) {
                    size = barMinSize;
                }

                if (this.bar) {
                    $(this.bar).css(this.origin.size, parseInt(size, 10) + 'px');
                }
            }

            // Updating top or left bar position
            function posBar(pos) {
                /* jshint validthis:true */
                if (this.bar) {
                    $(this.bar).css(this.origin.pos, +pos + 'px');
                }
            }

            // Free path for bar
            function k() {
                /* jshint validthis:true */
                return track[this.origin.client] - this.barTopLimit - this.bar[this.origin.offset];
            }

            // Relative content top position to bar top position
            function relToPos(r) {
                /* jshint validthis:true */
                return r * k.call(this) + this.barTopLimit;
            }

            // Bar position to relative content position
            function posToRel(t) {
                /* jshint validthis:true */
                return (t - this.barTopLimit) / k.call(this);
            }

            // Cursor position in main direction in px // Now with iOs support
            this.cursor = function(e) {
                return e['client' + this.origin.x] || (((e.originalEvent || e).touches || {})[0] || {})['page' + this.origin.x];
            };

            // Text selection pos preventing
            function dontPosSelect() {
                return false;
            }

            this.pos = function(x) { // Absolute scroller position in px
                var ie = 'page' + this.origin.x + 'Offset',
                    key = (this.scroller[ie]) ? ie : this.origin.scroll;

                if (x !== undefined) this.scroller[key] = x;

                return this.scroller[key];
            };

            this.rpos = function(r) { // Relative scroller position (0..1)
                var free = this.scroller[this.origin.scrollSize] - this.scroller[this.origin.client],
                    x;

                if (r) x = this.pos(r * free);
                else x = this.pos();

                return x / (free || 1);
            };

            // Switch on the bar by adding user-defined CSS classname to scroller
            this.barOn = function(dispose) {
                if (this.barOnCls) {
                    if (dispose || this.scroller[this.origin.client] >= this.scroller[this.origin.scrollSize]) {
                        $(this.root).removeClass(this.barOnCls);
                    } else {
                        $(this.root).addClass(this.barOnCls);
                    }
                }
            };

            this._pos0 = function(e) {
                scrollerPos0 = this.cursor(e) - barPos;
            };

            this.drag = function(e) {
                this.scroller[this.origin.scroll] = posToRel.call(this, this.cursor(e) - scrollerPos0) * (this.scroller[this.origin.scrollSize] - this.scroller[this.origin.client]);
            };

            // Text selection preventing on drag
            this.selection = function(enable) {
                this.event(document, 'selectpos selectstart', dontPosSelect, enable ? 'off' : 'on');
            };

            // onResize & DOM modified handler
            this.resize = function() {
                var self = this,
                    delay = 0;

                if (new Date().getTime() - resizeLastFire < pause) {
                    clearTimeout(resizePauseTimer);
                    delay = pause;
                }

                function upd() {
                    var delta = self.scroller[self.origin.crossOffset] - self.scroller[self.origin.crossClient];

                    if (params.freeze && !self.clipper.style[self.origin.crossSize]) { // Sould fire only once
                        $(self.clipper).css(self.origin.crossSize, self.clipper[self.origin.crossClient] - delta + 'px');
                    }
                    $(self.scroller).css(self.origin.crossSize, self.clipper[self.origin.crossClient] + delta + 'px');

                    Array.prototype.unshift.call(arguments, 'resize');
                    fire.apply(self, arguments);

                    resizeLastFire = new Date().getTime();
                }

                if (delay) {
                    resizePauseTimer = setTimeout(upd, delay);
                } else {
                    upd();
                }
            };

            // onScroll handler
            this.scroll = function() {
                var oldBarSize, newBarSize,
                    delay = 0,
                    self = this;

                if (new Date().getTime() - scrollLastFire < pause) {
                    clearTimeout(scrollPauseTimer);
                    delay = pause;
                }

                function upd() {
                    if (self.bar) {
                        newBarSize = (track[self.origin.client] - self.barTopLimit) * self.scroller[self.origin.client] / self.scroller[self.origin.scrollSize];

                        // Positioning bar
                        if (oldBarSize != newBarSize) {
                            setBarSize.call(self, newBarSize);
                            oldBarSize = newBarSize;
                        }

                        barPos = relToPos.call(self, self.rpos());

                        posBar.call(self, barPos);
                    }

                    Array.prototype.unshift.call( arguments, 'scroll' );
                    fire.apply(self, arguments);

                    scrollLastFire = new Date().getTime();
                }

                if (delay) {
                    scrollPauseTimer = setTimeout(upd, delay);
                } else {
                    upd();
                }

            };

            return this;
        },

        update: function(params) {
            fire.call(this, 'upd', params); // Обновляем параметры всех плагинов

            this.resize(1);
            this.barOn();
            this.scroll();

            return this;
        },

        dispose: function(params) {
            manageEvents(this, this.event, 'off');
            manageAttr(this.root, params.direction, 'off');
            $(this.scroller).css(this.origin.crossSize, '');
            this.barOn(true);
            fire.call(this, 'dispose');
        },

        on: function(eventName, func, arg) {
            var names = eventName.split(' ');

            for (var i = 0 ; i < names.length ; i++) {
                if (names[i] == 'init') {
                    func.call(this, arg);
                } else {
                    this.events[names[i]] = this.events[names[i]] || [];

                    this.events[names[i]].push(function(userArg) {
                        func.call(this, userArg || arg);
                    });
                }
            }
        }
    };

    baron.fn.constructor.prototype = baron.fn;
    item.prototype.constructor.prototype = item.prototype;

    // Use when you need "baron" global var for another purposes
    baron.noConflict = function() {
        window.baron = _baron; // Restoring original value of "baron" global var
        return baron;
    };

    baron.version = '0.6.6';

    if ($ && $.fn) { // Adding baron to jQuery as plugin
        $.fn.baron = baron;
    }
    window.baron = baron; // Use noConflict method if you need window.baron var for another purposes

    var fix = function(userParams) {
        var elements, viewPortSize,
            params = { // Default params
                outside: '',
                before: '',
                after: '',
                past: '',
                future: '',
                radius: 0,
                minView: 0
            },
            topFixHeights = [], // inline style for element
            topRealHeights = [], // real offset position when not fixed
            headerTops = [],
            scroller = this.scroller,
            eventManager = this.event,
            $ = this.$,
            self = this;

        function fixElement(i, pos) {
            if (viewPortSize < (params.minView || 0)) { // No headers fixing when no enought space for viewport
                pos = undefined;
            }

            if (pos !== undefined) {
                pos += 'px';
                this.$(elements[i]).css(this.origin.pos, pos).addClass(params.outside);
            } else {
                this.$(elements[i]).css(this.origin.pos, '').removeClass(params.outside);
            }
        }

        function bubbleWheel(e) {
            try {
                i = document.createEvent('WheelEvent'); // i - for extra byte
                // evt.initWebKitWheelEvent(deltaX, deltaY, window, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey);
                i.initWebKitWheelEvent(e.originalEvent.wheelDeltaX, e.originalEvent.wheelDeltaY);
                scroller.dispatchEvent(i);
                e.preventDefault();
            } catch (e) {}
        }

        function init(_params) {
            var pos;

            for (var key in _params) {
                params[key] = _params[key];
            }

            elements = this.$(params.elements, this.scroller);

            if (elements) {
                viewPortSize = this.scroller[this.origin.client];
                for (var i = 0 ; i < elements.length ; i++) {
                    // Variable header heights
                    pos = {};
                    pos[this.origin.size] = elements[i][this.origin.offset];
                    if (elements[i].parentNode !== this.scroller) {
                        this.$(elements[i].parentNode).css(pos);
                    }
                    pos = {};
                    pos[this.origin.crossSize] = elements[i].parentNode[this.origin.crossClient];
                    this.$(elements[i]).css(pos);

                    // Between fixed headers
                    viewPortSize -= elements[i][this.origin.offset];

                    headerTops[i] = elements[i].parentNode[this.origin.offsetPos]; // No paddings for parentNode

                    // Summary elements height above current
                    topFixHeights[i] = (topFixHeights[i - 1] || 0); // Not zero because of negative margins
                    topRealHeights[i] = (topRealHeights[i - 1] || Math.min(headerTops[i], 0));

                    if (elements[i - 1]) {
                        topFixHeights[i] += elements[i - 1][this.origin.offset];
                        topRealHeights[i] += elements[i - 1][this.origin.offset];
                    }

                    if ( !(i == 0 && headerTops[i] == 0)/* && force */) {
                        this.event(elements[i], 'mousewheel', bubbleWheel, 'off');
                        this.event(elements[i], 'mousewheel', bubbleWheel);
                    }
                }

                if (params.limiter && elements[0]) { // Bottom edge of first header as top limit for track
                    if (this.track && this.track != this.scroller) {
                        pos = {};
                        pos[this.origin.pos] = elements[0].parentNode[this.origin.offset];
                        this.$(this.track).css(pos);
                    } else {
                        this.barTopLimit = elements[0].parentNode[this.origin.offset];
                    }
                    // this.barTopLimit = elements[0].parentNode[this.origin.offset];
                    this.scroll();
                }

                if (params.limiter === false) { // undefined (in second fix instance) should have no influence on bar limit
                    this.barTopLimit = 0;
                }
            }

            var event = {
                element: elements,

                handler: function() {
                    var parent = $(this)[0].parentNode,
                        top = parent.offsetTop,
                        num;

                    // finding num -> elements[num] === this
                    for (var i = 0 ; i < elements.length ; i++ ) {
                        if (elements[i] === this) num = i;
                    }

                    var pos = top - topFixHeights[num];

                    if (params.scroll) { // User defined callback
                        params.scroll({
                            x1: self.scroller.scrollTop,
                            x2: pos
                        });
                    } else {
                        self.scroller.scrollTop = pos;
                    }
                },

                type: 'click'
            };

            if (params.clickable) {
                this._eventHandlers.push(event); // For auto-dispose
                eventManager(event.element, event.type, event.handler, 'off');
                eventManager(event.element, event.type, event.handler, 'on');
            }
        }

        this.on('init', init, userParams);

        this.on('init scroll', function() {
            var fixState, hTop,
                fixFlag = []; // 1 - past, 2 - future, 3 - current (not fixed)

            if (elements) {
                var change;

                // fixFlag update
                for (var i = 0 ; i < elements.length ; i++) {
                    fixState = 0;
                    if (headerTops[i] - this.pos() < topRealHeights[i] + params.radius) {
                        // Header trying to go up
                        fixState = 1;
                        hTop = topFixHeights[i];
                    } else if (headerTops[i] - this.pos() > topRealHeights[i] + viewPortSize - params.radius) {
                        // Header trying to go down
                        fixState = 2;
                        hTop = topFixHeights[i] + viewPortSize;
                    } else {
                        // Header in viewport
                        fixState = 3;
                        hTop = undefined;
                    }
                    if (fixState != fixFlag[i]) {
                        fixElement.call(this, i, hTop);
                        fixFlag[i] = fixState;
                        change = true;
                    }
                }

                // Adding positioning classes (on last top and first bottom header)
                if (change) { // At leats one change in elements flag structure occured
                    for (i = 0 ; i < elements.length ; i++) {
                        if (fixFlag[i] == 1 && params.past) {
                            this.$(elements[i]).addClass(params.past).removeClass(params.future);
                        }

                        if (fixFlag[i] == 2 && params.future) {
                            this.$(elements[i]).addClass(params.future).removeClass(params.past);
                        }

                        if (fixFlag[i] == 3 && (params.future || params.past)) {
                            this.$(elements[i]).removeClass(params.past).removeClass(params.future);
                        }

                        if (fixFlag[i] != fixFlag[i + 1] && fixFlag[i] == 1 && params.before) {
                            this.$(elements[i]).addClass(params.before).removeClass(params.after); // Last top fixed header
                        } else if (fixFlag[i] != fixFlag[i - 1] && fixFlag[i] == 2 && params.after) {
                            this.$(elements[i]).addClass(params.after).removeClass(params.before); // First bottom fixed header
                        } else {
                            this.$(elements[i]).removeClass(params.before).removeClass(params.after);
                        }
                    }
                }
            }
        });

        this.on('resize upd', function(updParams) {
            init.call(this, updParams && updParams.fix);
        });
    };

    baron.fn.fix = function(params) {
        var i = 0;

        while (this[i]) {
            fix.call(this[i], params);
            i++;
        }

        return this;
    };

    var controls = function(params) {
        var forward, backward, track, screen,
            self = this; // AAAAAA!!!!!11

        screen = params.screen || 0.9;

        if (params.forward) {
            forward = this.$(params.forward, this.clipper);

            this.event(forward, 'click', function() {
                var y = self.pos() - params.delta || 30;

                self.pos(y);
            });
        }

        if (params.backward) {
            backward = this.$(params.backward, this.clipper);

            this.event(backward, 'click', function() {
                var y = self.pos() + params.delta || 30;

                self.pos(y);
            });
        }

        if (params.track) {
            if (params.track === true) {
                track = this.track;
            } else {
                track = this.$(params.track, this.clipper)[0];
            }

            if (track) {
                this.event(track, 'mousedown', function(e) {
                    var x = e['offset' + self.origin.x],
                        xBar = self.bar[self.origin.offsetPos],
                        sign = 0;

                    if (x < xBar) {
                        sign = -1;
                    } else if (x > xBar + self.bar[self.origin.offset]) {
                        sign = 1;
                    }

                    var y = self.pos() + sign * screen * self.scroller[self.origin.client];
                    self.pos(y);
                });
            }
        }

    };

    baron.fn.controls = function(params) {
        var i = 0;

        while (this[i]) {
            controls.call(this[i], params);
            i++;
        }

        return this;
    };

    var pull = function(params) {
        var block = this.$(params.block),
            size = params.size || this.origin.size,
            limit = params.limit || 80,
            onExpand = params.onExpand,
            elements = params.elements || [],
            inProgress = params.inProgress || '',
            self = this,
            _insistence = 0,
            _zeroXCount = 0,
            _interval,
            _timer,
            _x = 0,
            _onExpandCalled,
            _waiting = params.waiting || 500,
            _on;

        function getSize() {
            return self.scroller[self.origin.scroll] + self.scroller[self.origin.offset];
        }

        // Scroller content height
        function getContentSize() {
            return self.scroller[self.origin.scrollSize];
        }

        // Scroller height
        function getScrollerSize() {
            return self.scroller[self.origin.client];
        }

        function step(x, force) {
            var k = x * 0.0005;

            return Math.floor(force - k * (x + 550));
        }

        function toggle(on) {
            _on = on;

            if (on) {
                update(); // First time with no delay
                _interval = setInterval(update, 200);
            } else {
                clearInterval(_interval);
            }
        }

        function update() {
            var pos = {},
                height = getSize(),
                scrollHeight = getContentSize(),
                dx,
                op4,
                scrollInProgress = _insistence == 1;

            op4 = 0; // Возвращающая сила
            if (_insistence > 0) {
                op4 = 40;
            }
            //if (_insistence > -1) {
                dx = step(_x, op4);
                if (height >= scrollHeight - _x && _insistence > -1) {
                    if (scrollInProgress) {
                        _x += dx;
                    }
                } else {
                    _x = 0;
                }

                if (_x < 0) _x = 0;

                pos[size] = _x + 'px';
                if (getScrollerSize() <= getContentSize()) {
                    self.$(block).css(pos);
                    for (var i = 0 ; i < elements.length ; i++) {
                        self.$(elements[i].self).css(elements[i].property, Math.min(_x / limit * 100, 100) + '%');
                    }
                }

                if (inProgress && _x) {
                    self.$(self.root).addClass(inProgress);
                }

                if (_x == 0) {
                    if (params.onCollapse) {
                        params.onCollapse();
                    }
                }

                _insistence = 0;
                _timer = setTimeout(function() {
                    _insistence = -1;
                }, _waiting);
            //}

            if (onExpand && _x > limit && !_onExpandCalled) {
                onExpand();
                _onExpandCalled = true;
            }

            if (_x == 0) {
                _zeroXCount++;
            } else {
                _zeroXCount = 0;

            }
            if (_zeroXCount > 1) {
                toggle(false);
                _onExpandCalled = false;
                if (inProgress) {
                    self.$(self.root).removeClass(inProgress);
                }
            }
        }

        this.on('init', function() {
            toggle(true);
        });

        this.on('dispose', function() {
            toggle(false);
        });

        this.event(this.scroller, 'mousewheel DOMMouseScroll', function(e) {
            var down = e.wheelDelta < 0 || (e.originalEvent && e.originalEvent.wheelDelta < 0) || e.detail > 0;

            if (down) {
                _insistence = 1;
                clearTimeout(_timer);
                if (!_on && getSize() >= getContentSize()) {
                    toggle(true);
                }
            }
            //  else {
            //     toggle(false);
            // }
        });
    };

    baron.fn.pull = function(params) {
        var i = 0;

        while (this[i]) {
            pull.call(this[i], params);
            i++;
        }

        return this;
    };
})(window);


================================================
FILE: vendors/baron/changelog.md
================================================
## 0.6.2

- dispose method added (to free memory and remove event listeners when scroller removed from dom)

## 0.6.0

core:
- Plugin system added (alpha version)
- fixable headers moved to 'fix' plugin
- 'grunt full' now includes test plugin to build
- 'u' method renamed to 'update'
- 0.2s delay for update on resize event removed (use 'pause' param instead)

params change
- 'bar' default value now 'undefined' (!)
- '$' param added, default value: window.jQuery
- 'dom' and 'selector' params removed
- 'direction' ['v', 'h'] param added, default value: 'v'.
- 'freeze' param added: size of scroller parent freezes at initialization, if true
- 'pause' param added: use it on slow hardware to limit event trigger frequency (minimum time delay between two triggers in seconds)
- all params for fixable headers moved to 'fix' plugin

fix plugin:
- 'header' param renamed to 'elements'
- 'hFixCls' param renamed to 'outside'
- 'hBeforeFixCls' param renamed to 'before'
- 'hAfterFixCls' param renamed to 'after'
- 'fixRadius' param renamed to 'radius'
- 'trackSmartLim' param renamed to 'limiter'

plugins:
- 'controls' plugin added
- 'test' plugin added

## 0.5.0

- Horizontal scroll support
- Textarea support
- Dev build added (with error console messages)

## 0.4.0

Improvements

- Grunt task runner for build customization added
- root var removed (use scroller param instead)
- barOnCls now applied to scroller, not the bar
- trackSmartLim param added (if true bottom edge of first header uses as bar top limit)
- fixRadius param added
- Variable (tex-dependent) headers heights support added
- noConflict method added

Bugs

- Right click drag bug fixed
- Update method now invalidates bar visibility
- Margin collapse and positioned elements bug fixed

Misc

- heightChange custom event renamed to sizeChange
- container param removed
- hTopFixCls param renamed to hBeforeFixCls
- hBottomFixCls param renamed to hAfterFixCls
- barTop param removed
- "require()" support added
- Server-side "usage" handler added

================================================
FILE: vendors/baron/demo/baron.full.js
================================================
(function(window, undefined) {
    'use strict';

    if (!window) return; // Server side

var
    _baron = window.baron, // Stored baron value for noConflict usage
    $ = window.jQuery, // Trying to use jQuery
    origin = {
        v: { // Vertical
            x: 'Y', pos: 'top', crossPos: 'left', size: 'height', crossSize: 'width',
            client: 'clientHeight', crossClient: 'clientWidth', offset: 'offsetHeight', crossOffset: 'offsetWidth', offsetPos: 'offsetTop',
            scroll: 'scrollTop', scrollSize: 'scrollHeight'
        },
        h: { // Horizontal
            x: 'X', pos: 'left', crossPos: 'top', size: 'width', crossSize: 'height',
            client: 'clientWidth', crossClient: 'clientHeight', offset: 'offsetWidth', crossOffset: 'offsetHeight', offsetPos: 'offsetLeft',
            scroll: 'scrollLeft', scrollSize: 'scrollWidth'
        }
    },

    each = function(obj, iterator) {
        var i = 0;

        if (obj.length === undefined || obj === window) obj = [obj];

        while (obj[i]) {
            iterator.call(this, obj[i], i);
            i++;
        }
    },

    baron = function(params) { // this - window or jQuery instance
        var jQueryMode = (this && this[0] && this[0].nodeType),
            roots,
            $;

        params = params || {};
        $ = params.$ || window.jQuery;

        if (jQueryMode) {
            params.root = roots = this;
        } else {
            roots = $(params.root || params.scroller);
        }

        return new baron.fn.constructor(roots, params, $);
    };

    baron.fn = {
        constructor: function(roots, input, $) {
            var params = validate(input);

            params.$ = $;
            each.call(this, roots, function(root, i) {
                var localParams = clone(params);

                if (params.root && params.scroller) {
                    localParams.scroller = params.$(params.scroller, root);
                    if (!localParams.scroller.length) {
                        localParams.scroller = root;
                    }
                } else {
                    localParams.scroller = root;
                }

                localParams.root = root;
                this[i] = init(localParams);
                this.length = i + 1;
            });

            this.params = params;
        },

        dispose: function() {
            var params = this.params;

            each(this, function(item) {
                item.dispose(params);
            });
            this.params = null;
        },

        update: function() {
            var i = 0;

            while (this[i]) {
                this[i].update.apply(this[i], arguments);
                i++;
            }
        },

        baron: function(params) {
            params.root = [];
            params.scroller = this.params.scroller;

            each.call(this, this, function(elem) {
                params.root.push(elem.root);
            });
            params.direction = (this.params.direction == 'v') ? 'h' : 'v';
            params._chain = true;

            return baron(params);
        }
    };

    function manageEvents(item, eventManager, mode) {
        item._eventHandlers = item._eventHandlers || [ // Creating new functions for one baron item only one time
            {
                // onScroll: 
                element: item.scroller,

                handler: function(e) {
                    item.scroll(e);
                },

                type: 'scroll'
            }, {
                // onMouseDown: 
                element: item.bar,

                handler: function(e) {
                    e.preventDefault(); // Text selection disabling in Opera... and all other browsers?
                    item.selection(); // Disable text selection in ie8
                    item.drag.now = 1; // Save private byte
                },

                type: 'touchstart mousedown'
            }, {
                // onMouseUp: 
                element: document,

                handler: function() {
                    item.selection(1); // Enable text selection
                    item.drag.now = 0;
                },

                type: 'mouseup blur touchend'
            }, {
                // onCoordinateReset: 
                element: document,

                handler: function(e) {
                    if (e.button != 2) { // Not RM
                        item._pos0(e);
                    }
                },

                type: 'touchstart mousedown'
            }, {
                // onMouseMove: 
                element: document,

                handler: function(e) {
                    if (item.drag.now) {
                        item.drag(e);
                    }
                },

                type: 'mousemove touchmove'
            }, {
                // onResize: 
                element: window,

                handler: function() {
                    item.update();
                },

                type: 'resize'
            }, {
                // sizeChange: 
                element: item.root,

                handler: function() {
                    item.update();
                },

                type: 'sizeChange'
            }
        ];

        each(item._eventHandlers, function(event) {
            if (event.element) {
                eventManager(event.element, event.type, event.handler, mode);
            }
        });

        // if (item.scroller) {
        //     event(item.scroller, 'scroll', item._eventHandlers.onScroll, mode);
        // }
        // if (item.bar) {
        //     event(item.bar, 'touchstart mousedown', item._eventHandlers.onMouseDown, mode);
        // }
        // event(document, 'mouseup blur touchend', item._eventHandlers.onMouseUp, mode);
        // event(document, 'touchstart mousedown', item._eventHandlers.onCoordinateReset, mode);
        // event(document, 'mousemove touchmove', item._eventHandlers.onMouseMove, mode);
        // event(window, 'resize', item._eventHandlers.onResize, mode);
        // if (item.root) {
        //     event(item.root, 'sizeChange', item._eventHandlers.onResize, mode); // Custon event for alternate baron update mechanism
        // }
    }

    function manageAttr(node, direction, mode) {
        var attrName = 'data-baron-' + direction;

        if (mode == 'on') {
            node.setAttribute(attrName, 'inited');
        } else if (mode == 'off') {
            node.removeAttribute(attrName);
        } else {
            return node.getAttribute(attrName);
        }
    }

    function init(params) {
        if (manageAttr(params.root, params.direction)) return;

        var out = new item.prototype.constructor(params); // __proto__ of returning object is baron.prototype

        manageEvents(out, params.event, 'on');

        manageAttr(out.root, params.direction, 'on');

        out.update();

        return out;
    }

    function clone(input) {
        var output = {};

        input = input || {};

        for (var key in input) {
            if (input.hasOwnProperty(key)) {
                output[key] = input[key];
            }
        }

        return output;
    }

    function validate(input) {
        var output = clone(input);

        output.direction = output.direction || 'v';

        var event = input.event || function(elem, event, func, mode) {
            output.$(elem)[mode || 'on'](event, func);
        };

        output.event = function(elems, e, func, mode) {
            each(elems, function(elem) {
                event(elem, e, func, mode);
            });
        };

        return output;
    }

    function fire(eventName) {
        /* jshint validthis:true */
        if (this.events && this.events[eventName]) {
            for (var i = 0 ; i < this.events[eventName].length ; i++) {
                var args = Array.prototype.slice.call( arguments, 1 );

                this.events[eventName][i].apply(this, args);
            }
        }
    }

    var item = {};

    item.prototype = {
        constructor: function(params) {
            var $,
                barPos,
                scrollerPos0,
                track,
                resizePauseTimer,
                scrollPauseTimer,
                pause,
                scrollLastFire,
                resizeLastFire;

            resizeLastFire = scrollLastFire = new Date().getTime();

            $ = this.$ = params.$;
            this.event = params.event;
            this.events = {};

            function getNode(sel, context) {
                return $(sel, context)[0]; // Can be undefined
            }

            // DOM elements
            this.root = params.root; // Always html node, not just selector
            this.scroller = getNode(params.scroller); // (params.scroller) ? getNode(params.scroller, this.root) : this.root;
            this.bar = getNode(params.bar, this.root);
            track = this.track = getNode(params.track, this.root);
            if (!this.track && this.bar) {
                track = this.bar.parentNode;
            }
            this.clipper = this.scroller.parentNode;

            // Parameters
            this.direction = params.direction;
            this.origin = origin[this.direction];
            this.barOnCls = params.barOnCls;
            this.barTopLimit = 0;
            pause = params.pause * 1000 || 0;

            // Updating height or width of bar
            function setBarSize(size) {
                /* jshint validthis:true */
                var barMinSize = this.barMinSize || 20;

                if (size > 0 && size < barMinSize) {
                    size = barMinSize;
                }

                if (this.bar) {
                    $(this.bar).css(this.origin.size, parseInt(size, 10) + 'px');
                }
            }

            // Updating top or left bar position
            function posBar(pos) {
                /* jshint validthis:true */
                if (this.bar) {
                    $(this.bar).css(this.origin.pos, +pos + 'px');
                }
            }

            // Free path for bar
            function k() {
                /* jshint validthis:true */
                return track[this.origin.client] - this.barTopLimit - this.bar[this.origin.offset];
            }

            // Relative content top position to bar top position
            function relToPos(r) {
                /* jshint validthis:true */
                return r * k.call(this) + this.barTopLimit;
            }

            // Bar position to relative content position
            function posToRel(t) {
                /* jshint validthis:true */
                return (t - this.barTopLimit) / k.call(this);
            }

            // Cursor position in main direction in px // Now with iOs support
            this.cursor = function(e) {
                return e['client' + this.origin.x] || (((e.originalEvent || e).touches || {})[0] || {})['page' + this.origin.x];
            };

            // Text selection pos preventing
            function dontPosSelect() {
                return false;
            }

            this.pos = function(x) { // Absolute scroller position in px
                var ie = 'page' + this.origin.x + 'Offset',
                    key = (this.scroller[ie]) ? ie : this.origin.scroll;

                if (x !== undefined) this.scroller[key] = x;

                return this.scroller[key];
            };

            this.rpos = function(r) { // Relative scroller position (0..1)
                var free = this.scroller[this.origin.scrollSize] - this.scroller[this.origin.client],
                    x;

                if (r) x = this.pos(r * free);
                else x = this.pos();

                return x / (free || 1);
            };

            // Switch on the bar by adding user-defined CSS classname to scroller
            this.barOn = function(dispose) {
                if (this.barOnCls) {
                    if (dispose || this.scroller[this.origin.client] >= this.scroller[this.origin.scrollSize]) {
                        $(this.root).removeClass(this.barOnCls);
                    } else {
                        $(this.root).addClass(this.barOnCls);
                    }
                }
            };

            this._pos0 = function(e) {
                scrollerPos0 = this.cursor(e) - barPos;
            };

            this.drag = function(e) {
                this.scroller[this.origin.scroll] = posToRel.call(this, this.cursor(e) - scrollerPos0) * (this.scroller[this.origin.scrollSize] - this.scroller[this.origin.client]);
            };

            // Text selection preventing on drag
            this.selection = function(enable) {
                this.event(document, 'selectpos selectstart', dontPosSelect, enable ? 'off' : 'on');
            };

            // onResize & DOM modified handler
            this.resize = function() {
                var self = this,
                    delay = 0;

                if (new Date().getTime() - resizeLastFire < pause) {
                    clearTimeout(resizePauseTimer);
                    delay = pause;
                }

                function upd() {
                    var delta = self.scroller[self.origin.crossOffset] - self.scroller[self.origin.crossClient];

                    if (params.freeze && !self.clipper.style[self.origin.crossSize]) { // Sould fire only once
                        $(self.clipper).css(self.origin.crossSize, self.clipper[self.origin.crossClient] - delta + 'px');
                    }
                    $(self.scroller).css(self.origin.crossSize, self.clipper[self.origin.crossClient] + delta + 'px');
                    
                    Array.prototype.unshift.call(arguments, 'resize');
                    fire.apply(self, arguments);

                    resizeLastFire = new Date().getTime();
                }

                if (delay) {
                    resizePauseTimer = setTimeout(upd, delay);
                } else {
                    upd();
                }
            };

            // onScroll handler
            this.scroll = function() {
                var oldBarSize, newBarSize,
                    delay = 0,
                    self = this;

                if (new Date().getTime() - scrollLastFire < pause) {
                    clearTimeout(scrollPauseTimer);
                    delay = pause;
                }

                function upd() {
                    if (self.bar) {
                        newBarSize = (track[self.origin.client] - self.barTopLimit) * self.scroller[self.origin.client] / self.scroller[self.origin.scrollSize];

                        // Positioning bar
                        if (oldBarSize != newBarSize) {
                            setBarSize.call(self, newBarSize);
                            oldBarSize = newBarSize;
                        }
                        
                        barPos = relToPos.call(self, self.rpos());

                        posBar.call(self, barPos);
                    }

                    Array.prototype.unshift.call( arguments, 'scroll' );
                    fire.apply(self, arguments);

                    scrollLastFire = new Date().getTime();
                }

                if (delay) {
                    scrollPauseTimer = setTimeout(upd, delay);
                } else {
                    upd();
                }
                
            };

            return this;
        },

        update: function(params) {
            fire.call(this, 'upd', params); // Обновляем параметры всех плагинов

            this.resize(1);
            this.barOn();
            this.scroll();

            return this;
        },

        dispose: function(params) {
            manageEvents(this, this.event, 'off');
            manageAttr(this.root, params.direction, 'off');
            $(this.scroller).css(this.origin.crossSize, '');
            this.barOn(true);
            fire.call(this, 'dispose');
        },

        on: function(eventName, func, arg) {
            var names = eventName.split(' ');

            for (var i = 0 ; i < names.length ; i++) {
                if (names[i] == 'init') {
                    func.call(this, arg);
                } else {
                    this.events[names[i]] = this.events[names[i]] || [];

                    this.events[names[i]].push(function(userArg) {
                        func.call(this, userArg || arg);
                    });
                }
            }
        }
    };

    baron.fn.constructor.prototype = baron.fn;
    item.prototype.constructor.prototype = item.prototype;

    // Use when you need "baron" global var for another purposes
    baron.noConflict = function() {
        window.baron = _baron; // Restoring original value of "baron" global var

        return baron;
    };

    baron.version = '0.6.6';

    if ($ && $.fn) { // Adding baron to jQuery as plugin
        $.fn.baron = baron;
    }
    window.baron = baron; // Use noConflict method if you need window.baron var for another purposes
    if (window['module'] && module.exports) {
        module.exports = baron.noConflict();
    }
})(window);
/* Fixable elements plugin for baron 0.6+ */
(function(window, undefined) {
    var fix = function(userParams) {
        var elements, viewPortSize,
            params = { // Default params
                outside: '',
                before: '',
                after: '',
                past: '',
                future: '',
                radius: 0,
                minView: 0
            },
            topFixHeights = [], // inline style for element
            topRealHeights = [], // real offset position when not fixed
            headerTops = [],
            scroller = this.scroller,
            eventManager = this.event,
            $ = this.$,
            self = this;

        function fixElement(i, pos) {
            if (viewPortSize < (params.minView || 0)) { // No headers fixing when no enought space for viewport
                pos = undefined;
            }

            if (pos !== undefined) {
                pos += 'px';
                this.$(elements[i]).css(this.origin.pos, pos).addClass(params.outside);
            } else {
                this.$(elements[i]).css(this.origin.pos, '').removeClass(params.outside);
            }
        }

        function bubbleWheel(e) {
            try {
                i = document.createEvent('WheelEvent'); // i - for extra byte
                // evt.initWebKitWheelEvent(deltaX, deltaY, window, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey);
                i.initWebKitWheelEvent(e.originalEvent.wheelDeltaX, e.originalEvent.wheelDeltaY);
                scroller.dispatchEvent(i);
                e.preventDefault();
            } catch (e) {}
        }

        function init(_params) {
            var pos;

            for (var key in _params) {
                params[key] = _params[key];
            }

            elements = this.$(params.elements, this.scroller);

            if (elements) {
                viewPortSize = this.scroller[this.origin.client];
                for (var i = 0 ; i < elements.length ; i++) {
                    // Variable header heights
                    pos = {};
                    pos[this.origin.size] = elements[i][this.origin.offset];
                    if (elements[i].parentNode !== this.scroller) {
                        this.$(elements[i].parentNode).css(pos);
                    }
                    pos = {};
                    pos[this.origin.crossSize] = elements[i].parentNode[this.origin.crossClient];
                    this.$(elements[i]).css(pos);

                    // Between fixed headers
                    viewPortSize -= elements[i][this.origin.offset];

                    headerTops[i] = elements[i].parentNode[this.origin.offsetPos]; // No paddings for parentNode

                    // Summary elements height above current
                    topFixHeights[i] = (topFixHeights[i - 1] || 0); // Not zero because of negative margins
                    topRealHeights[i] = (topRealHeights[i - 1] || Math.min(headerTops[i], 0));

                    if (elements[i - 1]) {
                        topFixHeights[i] += elements[i - 1][this.origin.offset];
                        topRealHeights[i] += elements[i - 1][this.origin.offset];
                    }

                    if ( !(i == 0 && headerTops[i] == 0)/* && force */) {
                        this.event(elements[i], 'mousewheel', bubbleWheel, 'off');
                        this.event(elements[i], 'mousewheel', bubbleWheel);
                    }
                }

                if (params.limiter && elements[0]) { // Bottom edge of first header as top limit for track
                    if (this.track && this.track != this.scroller) {
                        pos = {};
                        pos[this.origin.pos] = elements[0].parentNode[this.origin.offset];
                        this.$(this.track).css(pos);
                    } else {
                        this.barTopLimit = elements[0].parentNode[this.origin.offset];
                    }
                    // this.barTopLimit = elements[0].parentNode[this.origin.offset];
                    this.scroll();
                }

                if (params.limiter === false) { // undefined (in second fix instance) should have no influence on bar limit
                    this.barTopLimit = 0;
                }
            }

            var event = {
                element: elements,
                
                handler: function() {
                    var parent = $(this)[0].parentNode,
                        top = parent.offsetTop,
                        num;

                    // finding num -> elements[num] === this
                    for (var i = 0 ; i < elements.length ; i++ ) {
                        if (elements[i] === this) num = i;
                    }

                    var pos = top - topFixHeights[num];

                    if (params.scroll) { // User defined callback
                        params.scroll({
                            x1: self.scroller.scrollTop,
                            x2: pos
                        });
                    } else {
                        self.scroller.scrollTop = pos;
                    }
                },

                type: 'click'
            };

            if (params.clickable) {
                this._eventHandlers.push(event); // For auto-dispose
                eventManager(event.element, event.type, event.handler, 'off');
                eventManager(event.element, event.type, event.handler, 'on');
            }
        }

        this.on('init', init, userParams);

        this.on('init scroll', function() {
            var fixState, hTop,
                fixFlag = []; // 1 - past, 2 - future, 3 - current (not fixed)

            if (elements) {
                var change;

                // fixFlag update
                for (var i = 0 ; i < elements.length ; i++) {
                    fixState = 0;
                    if (headerTops[i] - this.pos() < topRealHeights[i] + params.radius) {
                        // Header trying to go up
                        fixState = 1;
                        hTop = topFixHeights[i];
                    } else if (headerTops[i] - this.pos() > topRealHeights[i] + viewPortSize - params.radius) {
                        // Header trying to go down
                        fixState = 2;
                        hTop = topFixHeights[i] + viewPortSize;
                    } else {
                        // Header in viewport
                        fixState = 3;
                        hTop = undefined;
                    }
                    if (fixState != fixFlag[i]) {
                        fixElement.call(this, i, hTop);
                        fixFlag[i] = fixState;
                        change = true;
                    }
                }

                // Adding positioning classes (on last top and first bottom header)
                if (change) { // At leats one change in elements flag structure occured
                    for (i = 0 ; i < elements.length ; i++) {
                        if (fixFlag[i] == 1 && params.past) {
                            this.$(elements[i]).addClass(params.past).removeClass(params.future);
                        }

                        if (fixFlag[i] == 2 && params.future) {
                            this.$(elements[i]).addClass(params.future).removeClass(params.past);
                        }

                        if (fixFlag[i] == 3 && (params.future || params.past)) {
                            this.$(elements[i]).removeClass(params.past).removeClass(params.future);
                        }

                        if (fixFlag[i] != fixFlag[i + 1] && fixFlag[i] == 1 && params.before) {
                            this.$(elements[i]).addClass(params.before).removeClass(params.after); // Last top fixed header
                        } else if (fixFlag[i] != fixFlag[i - 1] && fixFlag[i] == 2 && params.after) {
                            this.$(elements[i]).addClass(params.after).removeClass(params.before); // First bottom fixed header
                        } else {
                            this.$(elements[i]).removeClass(params.before).removeClass(params.after);
                        }
                    }
                }
            }
        });

        this.on('resize upd', function(updParams) {
            init.call(this, updParams && updParams.fix);
        });
    };

    baron.fn.fix = function(params) {
        var i = 0;

        while (this[i]) {
            fix.call(this[i], params);
            i++;
        }

        return this;
    };
})(window);
/* Controls plugin for baron 0.6+ */
(function(window, undefined) {
    var controls = function(params) {
        var forward, backward, track, screen,
            self = this; // AAAAAA!!!!!11

        screen = params.screen || 0.9;

        if (params.forward) {
            forward = this.$(params.forward, this.clipper);

            this.event(forward, 'click', function() {
                var y = self.pos() - params.delta || 30;
                
                self.pos(y);
            });
        }

        if (params.backward) {
            backward = this.$(params.backward, this.clipper);

            this.event(backward, 'click', function() {
                var y = self.pos() + params.delta || 30;

                self.pos(y);
            });
        }

        if (params.track) {
            if (params.track === true) {
                track = this.track;
            } else {
                track = this.$(params.track, this.clipper)[0];
            }

            if (track) {
                this.event(track, 'mousedown', function(e) {
                    var x = e['offset' + self.origin.x],
                        xBar = self.bar[self.origin.offsetPos],
                        sign = 0;

                    if (x < xBar) {
                        sign = -1;
                    } else if (x > xBar + self.bar[self.origin.offset]) {
                        sign = 1;
                    }

                    var y = self.pos() + sign * screen * self.scroller[self.origin.client];
                    self.pos(y);
                });
            }
        }

    };

    baron.fn.controls = function(params) {
        var i = 0;

        while (this[i]) {
            controls.call(this[i], params);
            i++;
        }

        return this;
    };
})(window);
/* Autotests plugin for baron 0.6+ (for developers) */
(function(window, undefined) {
    var test = function(params) {
        var errCount = 0,
            totalCount = 0;

        var log = function(type, msg, obj) {
            var text = type + ': ' + msg;

            switch (type) {
                case 'log': css = 'color: #0b0'; break;
                case 'warn': css = 'color: #fc9'; break;
                case 'error': css = 'color: #f00'; break;
            }
            totalCount++;
            if (type == 'log') {
                errCount++;
            }

            console.log('%c ' + totalCount + '. ' + text, css);
            if (obj !== undefined) {
                console.log(obj);
            }
        };

        if (this.scroller && this.scroller.nodeType === 1) {
            log('log', 'Scroller defined and has proper nodeType value', this.scroller);
        } else {
            log('error', 'Scroller not defined or has wrong type (should be html node).', this.scroller);
        }

        if (this.$ && typeof this.$ == 'function') {
            log('log', 'Local $ defined and it is a function');
        } else {
            log('error', 'Local $ has wrong value or is not defined, or custom params.dom and params.selector not defined', params.$);
        }

        if (this.scroller.getAttribute('data-baron-v')) {
            log('log', 'Baron initialized in vertical direction', this.scroller.getAttribute('data-baron-v'));
            if (this.scroller.clientHeight < this.scroller.scrollHeight && this.scroller.getAttribute('data-baron-v')) {
                log('log', 'There are enought space for scrolling in vertical direction right now', this.scroller.scrollHeight - this.scroller.clientHeight + 'px');
            } else {
                log('log', 'There are not enought space for scrolling in vertical direction right now');
            }
        }
        if (this.scroller.getAttribute('data-baron-h')) {
            log('log', 'Baron initialized in horizontal direction', this.scroller.getAttribute('data-baron-h'));
            if (this.scroller.clientWidth < this.scroller.scrollWidth) {
                log('log', 'There are enought space for scrolling in horizontal direction right now', this.scroller.scrollWidth - this.scroller.clientWidth + 'px');
            } else {
                log('log', 'There are not enought space for scrolling in horizontal direction right now');
            }
        }

        if (this.bar && this.bar.nodeType === 1) {
            log('log', 'Bar defined and has proper nodeType value', this.bar);
        } else {
            log('warn', 'Bar not defined or has wrong type (should be html node).', this.bar);
        }
        
        if (this.barOnCls) {
            log('log', 'CSS classname barOnCls defined', this.barOnCls);
        } else {
            log('warn', 'barOnCls not defined - bar will be visible or not visible all the time', this.barOnCls);
        }

        // Preformance test
        var t1 = new Date().getTime(),
            x;
        for (var i = 0 ; i < 1000 ; i += 10) {
            x = i % (this.scroller[this.origin.scrollSize] - this.scroller[this.origin.client]);
            this.pos(x);
            this.event(this.scroller, 'scroll', undefined, 'trigger');
        }
        var t2 = new Date().getTime();
        log('log', 'Preformance test: ' + (t2 - t1) / 1000 + ' milliseconds per scroll event');
        
        log('log', 'Result is ' + errCount + ' / ' + totalCount + '\n');
    };

    baron.fn.test = function(params) {
        var i = 0;

        while (this[i]) {
            test.call(this[i], params);
            i++;
        }

        return this;
    };
})(window);
/* Pull to load plugin for baron 0.6+ */
(function(window, undefined) {
    var pull = function(params) {
        var block = this.$(params.block),
            size = params.size || this.origin.size,
            limit = params.limit || 80,
            onExpand = params.onExpand,
            elements = params.elements || [],
            inProgress = params.inProgress || '',
            self = this,
            _insistence = 0,
            _zeroXCount = 0,
            _interval,
            _timer,
            _x = 0,
            _onExpandCalled,
            _waiting = params.waiting || 500,
            _on;

        function getSize() {
            return self.scroller[self.origin.scroll] + self.scroller[self.origin.offset];
        }

        // Scroller content height
        function getContentSize() {
            return self.scroller[self.origin.scrollSize];
        }

        // Scroller height
        function getScrollerSize() {
            return self.scroller[self.origin.client];
        }

        function step(x, force) {
            var k = x * 0.0005;
            
            return Math.floor(force - k * (x + 550));
        }

        function toggle(on) {
            _on = on;

            if (on) {
                update(); // First time with no delay
                _interval = setInterval(update, 200);
            } else {
                clearInterval(_interval);
            }
        }

        function update() {
            var pos = {},
                height = getSize(),
                scrollHeight = getContentSize(),
                dx,
                op4,
                scrollInProgress = _insistence == 1;

            op4 = 0; // Возвращающая сила
            if (_insistence > 0) {
                op4 = 40;
            }
            //if (_insistence > -1) {
                dx = step(_x, op4);
                if (height >= scrollHeight - _x && _insistence > -1) {
                    if (scrollInProgress) {
                        _x += dx;
                    }
                } else {
                    _x = 0;
                }

                if (_x < 0) _x = 0;

                pos[size] = _x + 'px';
                if (getScrollerSize() <= getContentSize()) {
                    self.$(block).css(pos);
                    for (var i = 0 ; i < elements.length ; i++) {
                        self.$(elements[i].self).css(elements[i].property, Math.min(_x / limit * 100, 100) + '%');
                    }
                }

                if (inProgress && _x) {
                    self.$(self.root).addClass(inProgress);
                }

                if (_x == 0) {
                    if (params.onCollapse) {
                        params.onCollapse();
                    }
                }

                _insistence = 0;
                _timer = setTimeout(function() {
                    _insistence = -1;
                }, _waiting);
            //}

            if (onExpand && _x > limit && !_onExpandCalled) {
                onExpand();
                _onExpandCalled = true;
            }

            if (_x == 0) {
                _zeroXCount++;
            } else {
                _zeroXCount = 0;
                
            }
            if (_zeroXCount > 1) {
                toggle(false);
                _onExpandCalled = false;
                if (inProgress) {
                    self.$(self.root).removeClass(inProgress);
                }
            }
        }

        this.on('init', function() {
            toggle(true);
        });

        this.on('dispose', function() {
            toggle(false);
        });

        this.event(this.scroller, 'mousewheel DOMMouseScroll', function(e) {
            var down = e.wheelDelta < 0 || (e.originalEvent && e.originalEvent.wheelDelta < 0) || e.detail > 0;

            if (down) {
                _insistence = 1;
                clearTimeout(_timer);
                if (!_on && getSize() >= getContentSize()) {
                    toggle(true);
                }
            }
            //  else {
            //     toggle(false);
            // }
        });
    };

    baron.fn.pull = function(params) {
        var i = 0;

        while (this[i]) {
            pull.call(this[i], params);
            i++;
        }

        return this;
    };
})(window);

================================================
FILE: vendors/baron/demo/index.html
================================================
<!doctype html>
<html>
<head>

    <meta charset="utf-8" />

    <script src="../js/jquery-1.9.0.js"></script>

    <script src="baron.full.js"></script>
    <script src="../src/pull.js"></script>
    <script src="script.js"></script>

    <link rel="stylesheet" type="text/css" href="../baron.css" />
    <link rel="stylesheet" type="text/css" href="style.css" />

    <title>Baron.js demo page</title>

</head>

<body>

    <div class="wrapper wrapper_1">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">Baron</h1>
                </div>
                <p class="text">Baron is a title of nobility. In the kingdom of England, the medieval Latin word baro, baronis was used originally to denote a tenant-in-chief of the early Norman kings who held his lands by the feudal tenure of "barony" (in Latin per baroniam), and who was entitled to attend the Great Council which by the 13th century had developed into the Parliament of England.
                <p class="text">The title was quite common in most European countries often in a slightly modified form. In Italian, the word used was Barone. The corresponding title in the Holy Roman Empire was Freiherr.
                <div class="header">
                    <h1 class="header__title">Etymology and very long header, more than one line. I said more! ++++++++++++++</h1>
                </div>
                <p class="text">The word baron comes from the Old French baron, from a Late Latin baro "man; servant, soldier, mercenary" (so used in Salic Law; Alemannic Law has barus in the same sense). Isidore in the 7th century thought the word was from Greek βαρύς "heavy" (because of the "heavy work" done by mercenaries), but the word is presumably of Old Frankish origin, cognate with Old English beorn meaning "warrior, nobleman"). Cornutus in the first century already reports a word barones which he took to be of Gaulish origin. He glosses it as meaning servos militum and explains it as meaning "stupid", by reference to classical Latin bāro "simpleton, dunce"; because of this early reference, the word has also been suggested to derive from an otherwise unknown Celtic *bar, but OED takes this to be "a figment".

                <div class="header">
                    <h1 class="header__title">Barons in the United Kingdom</h1>
                </div>
                <p class="text">In the Peerage of England, Peerage of Ireland, Peerage of Great Britain and the Peerage of the United Kingdom, barons form the lowest rank, placed immediately below viscounts. A female of baronial rank has the title baroness. Feudal baronies (or "baronies by tenure") are now obsolete in England and without any legal force but any such historical titles are held in gross, that is to say are deemed to be enveloped within a more modern extant peerage title also held by the holder, sometimes along with vestigial manorial rights and tenures by grand serjeanty.
                <p class="text">William I introduced "baron" as a rank in England to distinguish the men who had pledged their loyalty to him under the feudal system. Previously, in the Anglo-Saxon kingdom of England, the king's companions held the title of earl and in Scotland, the title of thane. All who held their feudal barony "in-chief of the king", that is with the king as his immediate overlord, became alike barones regis ("barons of the king"), bound to perform a stipulated annual military service, and obliged to attend his council. Eventually the greatest of the nobles, especially those in the marches, such as the Earls of Chester or the Bishops of Durham, whose territories were often deemed palatinate, that is to say "worthy of a prince", might refer to their own tenants as "barons", where lesser magnates spoke simply of their "men" (homines).
                <p class="text">Initially those who held land directly from the king by military service, from earls downwards, all bore alike the title of baron, which was thus the factor uniting all members of the ancient baronage as peers one of another. Under King Henry II, the Dialogus de Scaccario already distinguished between greater barons, who held per baroniam by knight's service, and lesser barons, who held manors. Technically, Lords of Manors are barons, or freemen, however they do not use the term as a title. John Selden in his esteemed work Titles of Honour writes, "The word Baro (Latin for Baron) hath been also so much communicated, that not only all Lords of Mannors have been from antient time, and are at this day called sometimes Barons (as in the stile of their Court Barons, which is Curia Baronis, &c. And I have read hors de son Barony in a barr to an Avowry for hors de son fee) But also the Judges of the Exchequer have it from antient time fixed on them."[4] Within a century of the Norman Conquest of 1066, as in the case of Thomas Becket in 1164, there arose the practice of sending to each greater baron a personal summons demanding his attendance at the King's Council, which evolved into the Parliament and later into the House of Lords, whilst as was stipulated in Magna Carta of 1215, the lesser barons of each county would receive a single summons as a group through the sheriff, and representatives only from their number would be elected to attend on behalf of the group. These representatives developed into the Knights of the Shire, elected by the County Court presided over by the sheriff, who themselves formed the precursor of the House of Commons. Thus appeared a definite distinction, which eventually had the effect of restricting to the greater barons alone the privileges and duties of peerage.
                <p class="text">Later, the king started to create new baronies in one of two ways: by a writ of summons directing a chosen man to attend Parliament, and in an even later development by letters patent. Writs of summons became the normal method in medieval times, displacing the method of feudal barony, but creation of baronies by letters patent is the sole method adopted in modern times. Since the adoption of summons by writ, baronies thus no longer relate directly to land-holding, and thus no more feudal baronies needed thenceforth to be created. Following the Modus Tenendi Parliamenta of 1419, the Tenures Abolition Act 1660, the Feudal Tenure Act (1662), and the Fines and Recoveries Act of 1834, titles of feudal barony became obsolete and without legal force.
                <p class="text">In the twentieth century Britain introduced the concept of non-hereditary life peers. All appointees to this distinction have been at the rank of baron. Life-peers are not counted as part of the aristocracy although in accordance with the tradition applied to hereditary peers they too are formally addressed in parliament by their peers as "The Noble Lord".
                <p class="text">In addition, baronies are often used by their holders as subsidiary titles, for example as courtesy titles for the son and heir of an Earl or higher peer.

                <div class="header">
                    <h1 class="header__title">Scotland</h1>
                </div>
                <p class="text">In Scotland, the rank of baron is a rank of the ancient feudal nobility of Scotland and refers to a holder of a feudal barony, formerly a feudal superiority over a proper territorial entity erected into a free barony by a Crown Charter, and is not usually considered a rank of Peerage; as such it can be transferred by either inheritance or conveyance.
                <p class="text">The Scottish equivalent of an English baron is a Lord of Parliament.

                <div class="header">
                    <h1 class="header__title">Style of address</h1>
                </div>
                <p class="text">Normally one refers to or addresses Baron [X] as Lord [X] and his wife as Lady [X]. In the case of women who hold baronies in their own right, they can be referred to as Baroness [X] as well as Lady [X]. In direct address, they can also be referred to as My Lord, Your Lordship, or Your Ladyship, but never as My Lady (except in the case of a female judge). The husband of a Baroness in her own right does not receive any style in her right. Children of Barons and Baronesses in their own right, whether hereditary or for life, have the style The Honourable [Forename] [Surname]. After the death of the father or mother, the child may continue to use the style Honourable.
                <p class="text">Scottish feudal barons style their surnames similarly to Clan Chiefs, with the name of their barony following their name, as in John Smith of Edinburgh or John Smith, Baron of Edinburgh.[5] Most formally, and in writing, they are styled as The Much Honoured Baron of Edinburgh. Their wives are styled Lady Edinburgh, or The Baroness of Edinburgh. The phrase Lady of Edinburgh is wrong, if the lady in question does not hold a Scottish barony in her own right. Orally, Scottish barons may be addressed with the name of their barony, as in Edinburgh or else as Baron without anything else following, which if present would suggest a peerage barony. Informally, when referring to a Scots feudal baron in the third person, the name Laird of [X] is used or simply [X].
                <p class="text">Non-Scottish barons are styled The Right Honourable The Lord [Barony]. Barons' wives are styled The Right Honourable The Lady [Barony]. Baronesses in their own right are either titled The Right Honourable The Baroness [Barony] or The Right Honourable The Lady [Barony], mainly based on personal preference (e.g., Margaret, Lady Thatcher and Brenda, Baroness Hale, both created baronesses in their own right). Note the order of the names. 'Lady Margaret Thatcher' would denote that she was the daughter of an earl, marquess or duke. Right Honourable is frequently abbreviated to Rt Hon. When referred to by the Sovereign in public instruments, The Right Honourable is changed to Our right trusty and well-beloved, with counsellor attached if they are a Privy Counsellor.
                <p class="text">Courtesy barons are styled simply Lord [Barony], and their wives are Lady [Barony]. The style of Right Honourable and/or the article "The" in front of the title is not used for them.

                <div class="header">
                    <h1 class="header__title">Coronet</h1>
                </div>
                <p class="text">A person holding a peerage in the rank of baron is entitled to a coronet bearing six silver balls (called pearls) around the rim, equally spaced and all of equal size and height. The rim itself is neither jeweled, nor "chased" (which is the case for the coronets of peers of higher degree).
                <p class="text">The actual coronet is mostly worn on certain ceremonial occasions, such as the coronation of a new monarch, but a baron can bear his coronet of rank on his coat of arms above the shield. In heraldry, the baron's coronet is shown with four of the balls visible.
                <p class="text">Scottish feudal barons were entitled to a red cap of maintenance (chapeau) turned up ermine if petitioning for a grant or matriculation of a coat of arms between the 1930s and 2004. This chapeau is identical to the red cap worn by an English baron, but without the silver balls or gilt. This is sometimes depicted in armorial paintings between the shield and the helmet. Additionally, if the baron is the head of a family he may include a chiefly coronet which is similar to a ducal coronet, but with four strawberry leaves. Because the chapeau was a relatively recent innovation, a number of ancient Arms of Scottish feudal barons do not display the chapeau. Now Scottish feudal barons are principally recognised by the baron's helm, which in Scotland is a steel helmet with grille of three grilles, garnished in gold. Occasionally the great tilting-helm garnished with gold is shown, or a helmet befitting a higher rank, if held.

                <div class="load">
                    <div class="load__value"></div>
                </div>
            </div>
        </div>
        <div class="scroller__bar-wrapper">
            <div class="scroller__bar"></div>
        </div>
    </div>

    <div class="wrapper wrapper_2">
        <div class="scroller">
            <p class="text">Baron is a title of nobility. In the kingdom of England, the medieval Latin word baro, baronis was used originally to denote a tenant-in-chief of the early Norman kings who held his lands by the feudal tenure of "barony" (in Latin per baroniam), and who was entitled to attend the Great Council which by the 13th century had developed into the Parliament of England.
            <p class="text">The title was quite common in most European countries often in a slightly modified form. In Italian, the word used was Barone. The corresponding title in the Holy Roman Empire was Freiherr.
            <div class="header">
                <h1 class="header__title">Sticky footer</h1>
            </div>
            <div class="scroller__bar"></div>
            <div class="scroller__bar scroller__bar_h"></div>
        </div>
    </div>

</body>

</html>

================================================
FILE: vendors/baron/demo/script.js
================================================
window.onload = function() {
    window.dima = baron({
        root: '.wrapper_1',
        scroller: '.scroller',
        bar: '.scroller__bar',
        barOnCls: 'baron'
    }).fix({
        elements: '.header__title',
        outside: 'header__title_state_fixed',
        before: 'header__title_position_top',
        after: 'header__title_position_bottom',
        clickable: true
    }).pull({
        block: '.load',
        elements: [{
            self: '.load__value',
            property: 'width'
        }],
        limit: 115,
        onExpand: function() {
            $('.load').css('background', 'red');
        }
    });

    baron({
        scroller: '.wrapper_2 .scroller',
        bar: '.scroller__bar',
        barOnCls: 'baron'
    }).fix({
        elements: '.header__title',
        outside: 'header__title_state_fixed',
        before: 'header__title_position_top',
        after: 'header__title_position_bottom'
    }).baron({
        barOnCls: 'baron_h',
        bar: '.scroller__bar_h'
    });
};

================================================
FILE: vendors/baron/demo/style.css
================================================
html, body {height: 100%;margin: 0; padding: 0; font-family: Verdana}

body {
    -moz-box-sizing: border-box;
    box-sizing: border-box;
    margin: 0 auto;
    padding: 10px;
    text-align: center;
}

.wrapper {
    display: inline-block;
    vertical-align: top;
    position: relative;
    overflow: hidden;
    width: 30%;
    height: 70%;
    
    background: #fff;
    border: 1px solid #fc9;
    box-shadow:
        0 5px 15px -3px rgba(0, 0, 0, .7),
        0 0 0 1px rgba(0, 0, 0, .05);
    text-align: left;
}
.scroller {
    height: 100%;
    overflow-y: scroll;
    /*-webkit-overflow-scrolling: touch;*/
    /* uncomment to accelerate scrolling on iOs */
}
.scroller::-webkit-scrollbar {
    width: 0;
}
.scroller__bar-wrapper {
    position: absolute;
    z-index: 3;
    top: 10px;
    bottom: 10px;
    right: 5px;
    width: 8px;
    border-radius: 5px;
    background: #ddf;
    background: rgba(0, 0, 255, .1);
    pointer-events: none;
}
.scroller__bar {
    position: absolute;
    z-index: 1;
    width: 8px;
    border-radius: 3px;
    background: #987;
    opacity: 0;
    -webkit-transition: opacity .2s linear;
    transition: opacity .2s linear;
    pointer-events: auto;
}
.scroller__bar:hover {
    opacity: .8;
}
.baron .scroller__bar {
    opacity: .6;
}
.baron_h .scroller__bar_h {
    opacity: .6;
    bottom: 30px;
}

.header__title {
    position: relative;
    z-index: 2;
    width: 100%;
    margin: 0;
    -moz-box-sizing: border-box;
    box-sizing: border-box;
    background: #ebe7e4;
    background-color: rgba(200, 209, 250, 1);
    box-shadow: 0 -1px 0 rgba(0, 0, 0, .05);
    color: #222;
    font-size: 14px;
    line-height: 20px; /* sync with .search-results__header-wrapper height */
    opacity: 1;
    -webkit-transition: background-color .2s;
    transition: background-color .2s;
    cursor: pointer;
}
.header__title_state_fixed {
    position: absolute;
    z-index: 1;
    background-color: rgba(220, 209, 250, .95);
    text-shadow: 0 0 5px #fff;
}
.header__title_position_top {
    background-color: rgba(200, 250, 200, .8);
}
.header__title_position_top:after {
    content: '';
    position: absolute;
    left: 0;
    bottom: -30px;
    width: 100%;
    height: 30px;
    background: -webkit-linear-gradient(top, rgba(255, 255, 255, 1) 0%, rgba(255, 255, 255, 0) 100%);
    background: linear-gradient(to bottom, rgba(255, 255, 255, 1) 0%, rgba(255, 255, 255, 0) 100%);
    pointer-events: none;
}
.header__title_position_bottom {
    background-color: rgba(250, 200, 200, .8);
}
.header__title_position_bottom:after {
    content: '';
    position: absolute;
    left: 0;
    top: -30px;
    width: 100%;
    height: 30px;
    background: -webkit-linear-gradient(top, rgba(255, 255, 255, 0) 0%, rgba(255, 255, 255, 1) 100%);
    background: linear-gradient(to bottom, rgba(255, 255, 255, 0) 0%, rgba(255, 255, 255, 1) 100%);
    pointer-events: none;
}

.wrapper_2 .text {
    width: 800px;
}
.wrapper_2 .header__title {
    position: absolute;
    bottom: 0;
    z-index: 1;
}
.wrapper_2 .header__title_state_fixed {
    position: static;
}

.text {
    overflow: hidden;
    margin: 10px;
    font-size: 12px;
}

.wrapper_iphone .header__title_state_fixed {
    position: relative;
}
.wrapper_iphone .header__title_position_top {
    position: absolute;
    top: 0;
}
.wrapper_iphone .header__title_position_bottom {
    position: absolute;
    bottom: 0;
}

.load {
    background: yellow;
    -webkit-transition: all .2s linear;
    transition: all .2s linear;
}
.load__value {
    background: green;
    width: 0%;
    height: 100%;
    -webkit-transition: all .2s linear;
    transition: all .2s linear;
}

================================================
FILE: vendors/baron/js/bean.js
================================================
/*!
  * Bean - copyright (c) Jacob Thornton 2011-2012
  * https://github.com/fat/bean
  * MIT license
  */
(function (name, context, definition) {
  if (typeof module != 'undefined' && module.exports) module.exports = definition()
  else if (typeof define == 'function' && define.amd) define(definition)
  else context[name] = definition()
})('bean', this, function (name, context) {
  name    = name    || 'bean'
  context = context || this

  var win            = window
    , old            = context[name]
    , namespaceRegex = /[^\.]*(?=\..*)\.|.*/
    , nameRegex      = /\..*/
    , addEvent       = 'addEventListener'
    , removeEvent    = 'removeEventListener'
    , doc            = document || {}
    , root           = doc.documentElement || {}
    , W3C_MODEL      = root[addEvent]
    , eventSupport   = W3C_MODEL ? addEvent : 'attachEvent'
    , ONE            = {} // singleton for quick matching making add() do one()

    , slice          = Array.prototype.slice
    , str2arr        = function (s, d) { return s.split(d || ' ') }
    , isString       = function (o) { return typeof o == 'string' }
    , isFunction     = function (o) { return typeof o == 'function' }

      // events that we consider to be 'native', anything not in this list will
      // be treated as a custom event
    , standardNativeEvents =
        'click dblclick mouseup mousedown contextmenu '                  + // mouse buttons
        'mousewheel mousemultiwheel DOMMouseScroll '                     + // mouse wheel
        'mouseover mouseout mousemove selectstart selectend '            + // mouse movement
        'keydown keypress keyup '                                        + // keyboard
        'orientationchange '                                             + // mobile
        'focus blur change reset select submit '                         + // form elements
        'load unload beforeunload resize move DOMContentLoaded '         + // window
        'readystatechange message '                                      + // window
        'error abort scroll '                                              // misc
      // element.fireEvent('onXYZ'... is not forgiving if we try to fire an event
      // that doesn't actually exist, so make sure we only do these on newer browsers
    , w3cNativeEvents =
        'show '                                                          + // mouse buttons
        'input invalid '                                                 + // form elements
        'touchstart touchmove touchend touchcancel '                     + // touch
        'gesturestart gesturechange gestureend '                         + // gesture
        'textinput'                                                      + // TextEvent
        'readystatechange pageshow pagehide popstate '                   + // window
        'hashchange offline online '                                     + // window
        'afterprint beforeprint '                                        + // printing
        'dragstart dragenter dragover dragleave drag drop dragend '      + // dnd
        'loadstart progress suspend emptied stalled loadmetadata '       + // media
        'loadeddata canplay canplaythrough playing waiting seeking '     + // media
        'seeked ended durationchange timeupdate play pause ratechange '  + // media
        'volumechange cuechange '                                        + // media
        'checking noupdate downloading cached updateready obsolete '       // appcache

      // convert to a hash for quick lookups
    , nativeEvents = (function (hash, events, i) {
        for (i = 0; i < events.length; i++) events[i] && (hash[events[i]] = 1)
        return hash
      }({}, str2arr(standardNativeEvents + (W3C_MODEL ? w3cNativeEvents : ''))))

      // custom events are events that we *fake*, they are not provided natively but
      // we can use native events to generate them
    , customEvents = (function () {
        var isAncestor = 'compareDocumentPosition' in root
              ? function (element, container) {
                  return container.compareDocumentPosition && (container.compareDocumentPosition(element) & 16) === 16
                }
              : 'contains' in root
                ? function (element, container) {
                    container = container.nodeType === 9 || container === window ? root : container
                    return container !== element && container.contains(element)
                  }
                : function (element, container) {
                    while (element = element.parentNode) if (element === container) return 1
                    return 0
                  }
          , check = function (event) {
              var related = event.relatedTarget
              return !related
                ? related == null
                : (related !== this && related.prefix !== 'xul' && !/document/.test(this.toString())
                    && !isAncestor(related, this))
            }

        return {
            mouseenter: { base: 'mouseover', condition: check }
          , mouseleave: { base: 'mouseout', condition: check }
          , mousewheel: { base: /Firefox/.test(navigator.userAgent) ? 'DOMMouseScroll' : 'mousewheel' }
        }
      }())

      // we provide a consistent Event object across browsers by taking the actual DOM
      // event object and generating a new one from its properties.
    , Event = (function () {
            // a whitelist of properties (for different event types) tells us what to check for and copy
        var commonProps  = str2arr('altKey attrChange attrName bubbles cancelable ctrlKey currentTarget ' +
              'detail eventPhase getModifierState isTrusted metaKey relatedNode relatedTarget shiftKey '  +
              'srcElement target timeStamp type view which propertyName')
          , mouseProps   = commonProps.concat(str2arr('button buttons clientX clientY dataTransfer '      +
              'fromElement offsetX offsetY pageX pageY screenX screenY toElement'))
          , mouseWheelProps = mouseProps.concat(str2arr('wheelDelta wheelDeltaX wheelDeltaY wheelDeltaZ ' +
              'axis')) // 'axis' is FF specific
          , keyProps     = commonProps.concat(str2arr('char charCode key keyCode keyIdentifier '          +
              'keyLocation location'))
          , textProps    = commonProps.concat(str2arr('data'))
          , touchProps   = commonProps.concat(str2arr('touches targetTouches changedTouches scale rotation'))
          , messageProps = commonProps.concat(str2arr('data origin source'))
          , stateProps   = commonProps.concat(str2arr('state'))
          , overOutRegex = /over|out/
            // some event types need special handling and some need special properties, do that all here
          , typeFixers   = [
                { // key events
                    reg: /key/i
                  , fix: function (event, newEvent) {
                      newEvent.keyCode = event.keyCode || event.which
                      return keyProps
                    }
                }
              , { // mouse events
                    reg: /click|mouse(?!(.*wheel|scroll))|menu|drag|drop/i
                  , fix: function (event, newEvent, type) {
                      newEvent.rightClick = event.which === 3 || event.button === 2
                      newEvent.pos = { x: 0, y: 0 }
                      if (event.pageX || event.pageY) {
                        newEvent.clientX = event.pageX
                        newEvent.clientY = event.pageY
                      } else if (event.clientX || event.clientY) {
                        newEvent.clientX = event.clientX + doc.body.scrollLeft + root.scrollLeft
                        newEvent.clientY = event.clientY + doc.body.scrollTop + root.scrollTop
                      }
                      if (overOutRegex.test(type)) {
                        newEvent.relatedTarget = event.relatedTarget
                          || event[(type == 'mouseover' ? 'from' : 'to') + 'Element']
                      }
                      return mouseProps
                    }
                }
              , { // mouse wheel events
                    reg: /mouse.*(wheel|scroll)/i
                  , fix: function () { return mouseWheelProps }
                }
              , { // TextEvent
                    reg: /^text/i
                  , fix: function () { return textProps }
                }
              , { // touch and gesture events
                    reg: /^touch|^gesture/i
                  , fix: function () { return touchProps }
                }
              , { // message events
                    reg: /^message$/i
                  , fix: function () { return messageProps }
                }
              , { // popstate events
                    reg: /^popstate$/i
                  , fix: function () { return stateProps }
                }
              , { // everything else
                    reg: /.*/
                  , fix: function () { return commonProps }
                }
            ]
          , typeFixerMap = {} // used to map event types to fixer functions (above), a basic cache mechanism

          , Event = function (event, element, isNative) {
              if (!arguments.length) return
              event = event || ((element.ownerDocument || element.document || element).parentWindow || win).event
              this.originalEvent = event
              this.isNative       = isNative
              this.isBean         = true

              if (!event) return

              var type   = event.type
                , target = event.target || event.srcElement
                , i, l, p, props, fixer

              this.target = target && target.nodeType === 3 ? target.parentNode : target

              if (isNative) { // we only need basic augmentation on custom events, the rest expensive & pointless
                fixer = typeFixerMap[type]
                if (!fixer) { // haven't encountered this event type before, map a fixer function for it
                  for (i = 0, l = typeFixers.length; i < l; i++) {
                    if (typeFixers[i].reg.test(type)) { // guaranteed to match at least one, last is .*
                      typeFixerMap[type] = fixer = typeFixers[i].fix
                      break
                    }
                  }
                }

                props = fixer(event, this, type)
                for (i = props.length; i--;) {
                  if (!((p = props[i]) in this) && p in event) this[p] = event[p]
                }
              }
            }

        // preventDefault() and stopPropagation() are a consistent interface to those functions
        // on the DOM, stop() is an alias for both of them together
        Event.prototype.preventDefault = function () {
          if (this.originalEvent.preventDefault) this.originalEvent.preventDefault()
          else this.originalEvent.returnValue = false
        }
        Event.prototype.stopPropagation = function () {
          if (this.originalEvent.stopPropagation) this.originalEvent.stopPropagation()
          else this.originalEvent.cancelBubble = true
        }
        Event.prototype.stop = function () {
          this.preventDefault()
          this.stopPropagation()
          this.stopped = true
        }
        // stopImmediatePropagation() has to be handled internally because we manage the event list for
        // each element
        // note that originalElement may be a Bean#Event object in some situations
        Event.prototype.stopImmediatePropagation = function () {
          if (this.originalEvent.stopImmediatePropagation) this.originalEvent.stopImmediatePropagation()
          this.isImmediatePropagationStopped = function () { return true }
        }
        Event.prototype.isImmediatePropagationStopped = function () {
          return this.originalEvent.isImmediatePropagationStopped && this.originalEvent.isImmediatePropagationStopped()
        }
        Event.prototype.clone = function (currentTarget) {
          //TODO: this is ripe for optimisation, new events are *expensive*
          // improving this will speed up delegated events
          var ne = new Event(this, this.element, this.isNative)
          ne.currentTarget = currentTarget
          return ne
        }

        return Event
      }())

      // if we're in old IE we can't do onpropertychange on doc or win so we use doc.documentElement for both
    , targetElement = function (element, isNative) {
        return !W3C_MODEL && !isNative && (element === doc || element === win) ? root : element
      }

      /**
        * Bean maintains an internal registry for event listeners. We don't touch elements, objects
        * or functions to identify them, instead we store everything in the registry.
        * Each event listener has a RegEntry object, we have one 'registry' for the whole instance.
        */
    , RegEntry = (function () {
        // each handler is wrapped so we can handle delegation and custom events
        var wrappedHandler = function (element, fn, condition, args) {
            var call = function (event, eargs) {
                  return fn.apply(element, args ? slice.call(eargs, event ? 0 : 1).concat(args) : eargs)
                }
              , findTarget = function (event, eventElement) {
                  return fn.__beanDel ? fn.__beanDel.ft(event.target, element) : eventElement
                }
              , handler = condition
                  ? function (event) {
                      var target = findTarget(event, this) // deleated event
                      if (condition.apply(target, arguments)) {
                        if (event) event.currentTarget = target
                        return call(event, arguments)
                      }
                    }
                  : function (event) {
                      if (fn.__beanDel) event = event.clone(findTarget(event)) // delegated event, fix the fix
                      return call(event, arguments)
                    }
            handler.__beanDel = fn.__beanDel
            return handler
          }

        , RegEntry = function (element, type, handler, original, namespaces, args, root) {
            var customType     = customEvents[type]
              , isNative

            if (type == 'unload') {
              // self clean-up
              handler = once(removeListener, element, type, handler, original)
            }

            if (customType) {
              if (customType.condition) {
                handler = wrappedHandler(element, handler, customType.condition, args)
              }
              type = customType.base || type
            }

            this.isNative      = isNative = nativeEvents[type] && !!element[eventSupport]
            this.customType    = !W3C_MODEL && !isNative && type
            this.element       = element
            this.type          = type
            this.original      = original
            this.namespaces    = namespaces
            this.eventType     = W3C_MODEL || isNative ? type : 'propertychange'
            this.target        = targetElement(element, isNative)
            this[eventSupport] = !!this.target[eventSupport]
            this.root          = root
            this.handler       = wrappedHandler(element, handler, null, args)
          }

        // given a list of namespaces, is our entry in any of them?
        RegEntry.prototype.inNamespaces = function (checkNamespaces) {
          var i, j, c = 0
          if (!checkNamespaces) return true
          if (!this.namespaces) return false
          for (i = checkNamespaces.length; i--;) {
            for (j = this.namespaces.length; j--;) {
              if (checkNamespaces[i] == this.namespaces[j]) c++
            }
          }
          return checkNamespaces.length === c
        }

        // match by element, original fn (opt), handler fn (opt)
        RegEntry.prototype.matches = function (checkElement, checkOriginal, checkHandler) {
          return this.element === checkElement &&
            (!checkOriginal || this.original === checkOriginal) &&
            (!checkHandler || this.handler === checkHandler)
        }

        return RegEntry
      }())

    , registry = (function () {
        // our map stores arrays by event type, just because it's better than storing
        // everything in a single array.
        // uses '$' as a prefix for the keys for safety and 'r' as a special prefix for
        // rootListeners so we can look them up fast
        var map = {}

          // generic functional search of our registry for matching listeners,
          // `fn` returns false to break out of the loop
          , forAll = function (element, type, original, handler, root, fn) {
              var pfx = root ? 'r' : '$'
              if (!type || type == '*') {
                // search the whole registry
                for (var t in map) {
                  if (t.charAt(0) == pfx) {
                    forAll(element, t.substr(1), original, handler, root, fn)
                  }
                }
              } else {
                var i = 0, l, list = map[pfx + type], all = element == '*'
                if (!list) return
                for (l = list.length; i < l; i++) {
                  if ((all || list[i].matches(element, original, handler)) && !fn(list[i], list, i, type)) return
                }
              }
            }

          , has = function (element, type, original, root) {
              // we're not using forAll here simply because it's a bit slower and this
              // needs to be fast
              var i, list = map[(root ? 'r' : '$') + type]
              if (list) {
                for (i = list.length; i--;) {
                  if (!list[i].root && list[i].matches(element, original, null)) return true
                }
              }
              return false
            }

          , get = function (element, type, original, root) {
              var entries = []
              forAll(element, type, original, null, root, function (entry) {
                return entries.push(entry)
              })
              return entries
            }

          , put = function (entry) {
              var has = !entry.root && !this.has(entry.element, entry.type, null, false)
                , key = (entry.root ? 'r' : '$') + entry.type
              ;(map[key] || (map[key] = [])).push(entry)
              return has
            }

          , del = function (entry) {
              forAll(entry.element, entry.type, null, entry.handler, entry.root, function (entry, list, i) {
                list.splice(i, 1)
                entry.removed = true
                if (list.length === 0) delete map[(entry.root ? 'r' : '$') + entry.type]
                return false
              })
            }

            // dump all entries, used for onunload
          , entries = function () {
              var t, entries = []
              for (t in map) {
                if (t.charAt(0) == '$') entries = entries.concat(map[t])
              }
              return entries
            }

        return { has: has, get: get, put: put, del: del, entries: entries }
      }())

      // we need a selector engine for delegated events, use querySelectorAll if it exists
      // but for older browsers we need Qwery, Sizzle or similar
    , selectorEngine
    , setSelectorEngine = function (e) {
        if (!arguments.length) {
          selectorEngine = doc.querySelectorAll
            ? function (s, r) {
                return r.querySelectorAll(s)
              }
            : function () {
                throw new Error('Bean: No selector engine installed') // eeek
              }
        } else {
          selectorEngine = e
        }
      }

      // we attach this listener to each DOM event that we need to listen to, only once
      // per event type per DOM element
    , rootListener = function (event, type) {
        if (!W3C_MODEL && type && event && event.propertyName != '_on' + type) return

        var listeners = registry.get(this, type || event.type, null, false)
          , l = listeners.length
          , i = 0

        event = new Event(event, this, true)
        if (type) event.type = type

        // iterate through all handlers registered for this type, calling them unless they have
        // been removed by a previous handler or stopImmediatePropagation() has been called
        for (; i < l && !event.isImmediatePropagationStopped(); i++) {
          if (!listeners[i].removed) listeners[i].handler.call(this, event)
        }
      }

      // add and remove listeners to DOM elements
    , listener = W3C_MODEL
        ? function (element, type, add) {
            // new browsers
            element[add ? addEvent : removeEvent](type, rootListener, false)
          }
        : function (element, type, add, custom) {
            // IE8 and below, use attachEvent/detachEvent and we have to piggy-back propertychange events
            // to simulate event bubbling etc.
            var entry
            if (add) {
              registry.put(entry = new RegEntry(
                  element
                , custom || type
                , function (event) { // handler
                    rootListener.call(element, event, custom)
                  }
                , rootListener
                , null
                , null
                , true // is root
              ))
              if (custom && element['_on' + custom] == null) element['_on' + custom] = 0
              entry.target.attachEvent('on' + entry.eventType, entry.handler)
            } else {
              entry = registry.get(element, custom || type, rootListener, true)[0]
              if (entry) {
                entry.target.detachEvent('on' + entry.eventType, entry.handler)
                registry.del(entry)
              }
            }
          }

    , once = function (rm, element, type, fn, originalFn) {
        // wrap the handler in a handler that does a remove as well
        return function () {
          fn.apply(this, arguments)
          rm(element, type, originalFn)
        }
      }

    , removeListener = function (element, orgType, handler, namespaces) {
        var type     = orgType && orgType.replace(nameRegex, '')
          , handlers = registry.get(element, type, null, false)
          , removed  = {}
          , i, l

        for (i = 0, l = handlers.length; i < l; i++) {
          if ((!handler || handlers[i].original === handler) && handlers[i].inNamespaces(namespaces)) {
            // TODO: this is problematic, we have a registry.get() and registry.del() that
            // both do registry searches so we waste cycles doing this. Needs to be rolled into
            // a single registry.forAll(fn) that removes while finding, but the catch is that
            // we'll be splicing the arrays that we're iterating over. Needs extra tests to
            // make sure we don't screw it up. @rvagg
            registry.del(handlers[i])
            if (!removed[handlers[i].eventType] && handlers[i][eventSupport])
              removed[handlers[i].eventType] = { t: handlers[i].eventType, c: handlers[i].type }
          }
        }
        // check each type/element for removed listeners and remove the rootListener where it's no longer needed
        for (i in removed) {
          if (!registry.has(element, removed[i].t, null, false)) {
            // last listener of this type, remove the rootListener
            listener(element, removed[i].t, false, removed[i].c)
          }
        }
      }

      // set up a delegate helper using the given selector, wrap the handler function
    , delegate = function (selector, fn) {
        //TODO: findTarget (therefore $) is called twice, once for match and once for
        // setting e.currentTarget, fix this so it's only needed once
        var findTarget = function (target, root) {
              var i, array = isString(selector) ? selectorEngine(selector, root) : selector
              for (; target && target !== root; target = target.parentNode) {
                for (i = array.length; i--;) {
                  if (array[i] === target) return target
                }
              }
            }
          , handler = function (e) {
              var match = findTarget(e.target, this)
              if (match) fn.apply(match, arguments)
            }

        // __beanDel isn't pleasant but it's a private function, not exposed outside of Bean
        handler.__beanDel = {
            ft       : findTarget // attach it here for customEvents to use too
          , selector : selector
        }
        return handler
      }

    , fireListener = W3C_MODEL ? function (isNative, type, element) {
        // modern browsers, do a proper dispatchEvent()
        var evt = doc.createEvent(isNative ? 'HTMLEvents' : 'UIEvents')
        evt[isNative ? 'initEvent' : 'initUIEvent'](type, true, true, win, 1)
        element.dispatchEvent(evt)
      } : function (isNative, type, element) {
        // old browser use onpropertychange, just increment a custom property to trigger the event
        element = targetElement(element, isNative)
        isNative ? element.fireEvent('on' + type, doc.createEventObject()) : element['_on' + type]++
      }

      /**
        * Public API: off(), on(), add(), (remove()), one(), fire(), clone()
        */

      /**
        * off(element[, eventType(s)[, handler ]])
        */
    , off = function (element, typeSpec, fn) {
        var isTypeStr = isString(typeSpec)
          , k, type, namespaces, i

        if (isTypeStr && typeSpec.indexOf(' ') > 0) {
          // off(el, 't1 t2 t3', fn) or off(el, 't1 t2 t3')
          typeSpec = str2arr(typeSpec)
          for (i = typeSpec.length; i--;)
            off(element, typeSpec[i], fn)
          return element
        }

        type = isTypeStr && typeSpec.replace(nameRegex, '')
        if (type && customEvents[type]) type = customEvents[type].base

        if (!typeSpec || isTypeStr) {
          // off(el) or off(el, t1.ns) or off(el, .ns) or off(el, .ns1.ns2.ns3)
          if (namespaces = isTypeStr && typeSpec.replace(namespaceRegex, '')) namespaces = str2arr(namespaces, '.')
          removeListener(element, type, fn, namespaces)
        } else if (isFunction(typeSpec)) {
          // off(el, fn)
          removeListener(element, null, typeSpec)
        } else {
          // off(el, { t1: fn1, t2, fn2 })
          for (k in typeSpec) {
            if (typeSpec.hasOwnProperty(k)) off(element, k, typeSpec[k])
          }
        }

        return element
      }

      /**
        * on(element, eventType(s)[, selector], handler[, args ])
        */
    , on = function(element, events, selector, fn) {
        var originalFn, type, types, i, args, entry, first

        //TODO: the undefined check means you can't pass an 'args' argument, fix this perhaps?
        if (selector === undefined && typeof events == 'object') {
          //TODO: this can't handle delegated events
          for (type in events) {
            if (events.hasOwnProperty(type)) {
              on.call(this, element, type, events[type])
            }
          }
          return
        }

        if (!isFunction(selector)) {
          // delegated event
          originalFn = fn
          args       = slice.call(arguments, 4)
          fn         = delegate(selector, originalFn, selectorEngine)
        } else {
          args       = slice.call(arguments, 3)
          fn         = originalFn = selector
        }

        types = str2arr(events)

        // special case for one(), wrap in a self-removing handler
        if (this === ONE) {
          fn = once(off, element, events, fn, originalFn)
        }

        for (i = types.length; i--;) {
          // add new handler to the registry and check if it's the first for this element/type
          first = registry.put(entry = new RegEntry(
              element
            , types[i].replace(nameRegex, '') // event type
            , fn
            , originalFn
            , str2arr(types[i].replace(namespaceRegex, ''), '.') // namespaces
            , args
            , false // not root
          ))
          if (entry[eventSupport] && first) {
            // first event of this type on this element, add root listener
            listener(element, entry.eventType, true, entry.customType)
          }
        }

        return element
      }

      /**
        * add(element[, selector], eventType(s), handler[, args ])
        *
        * Deprecated: kept (for now) for backward-compatibility
        */
    , add = function (element, events, fn, delfn) {
        return on.apply(
            null
          , !isString(fn)
              ? slice.call(arguments)
              : [ element, fn, events, delfn ].concat(arguments.length > 3 ? slice.call(arguments, 5) : [])
        )
      }

      /**
        * one(element, eventType(s)[, selector], handler[, args ])
        */
    , one = function () {
        return on.apply(ONE, arguments)
      }

      /**
        * fire(element, eventType(s)[, args ])
        *
        * The optional 'args' argument must be an array, if no 'args' argument is provided
        * then we can use the browser's DOM event system, otherwise we trigger handlers manually
        */
    , fire = function (element, type, args) {
        var types = str2arr(type)
          , i, j, l, names, handlers

        for (i = types.length; i--;) {
          type = types[i].replace(nameRegex, '')
          if (names = types[i].replace(namespaceRegex, '')) names = str2arr(names, '.')
          if (!names && !args && element[eventSupport]) {
            fireListener(nativeEvents[type], type, element)
          } else {
            // non-native event, either because of a namespace, arguments or a non DOM element
            // iterate over all listeners and manually 'fire'
            handlers = registry.get(element, type, null, false)
            args = [false].concat(args)
            for (j = 0, l = handlers.length; j < l; j++) {
              if (handlers[j].inNamespaces(names)) {
                handlers[j].handler.apply(element, args)
              }
            }
          }
        }
        return element
      }

      /**
        * clone(dstElement, srcElement[, eventType ])
        *
        * TODO: perhaps for consistency we should allow the same flexibility in type specifiers?
        */
    , clone = function (element, from, type) {
        var handlers = registry.get(from, type, null, false)
          , l = handlers.length
          , i = 0
          , args, beanDel

        for (; i < l; i++) {
          if (handlers[i].original) {
            args = [ element, handlers[i].type ]
            if (beanDel = handlers[i].handler.__beanDel) args.push(beanDel.selector)
            args.push(handlers[i].original)
            on.apply(null, args)
          }
        }
        return element
      }

    , bean = {
          on                : on
        , add               : add
        , one               : one
        , off               : off
        , remove            : off
        , clone             : clone
        , fire              : fire
        , setSelectorEngine : setSelectorEngine
        , noConflict        : function () {
            context[name] = old
            return this
          }
      }

  // for IE, clean up on unload to avoid leaks
  if (win.attachEvent) {
    var cleanup = function () {
      var i, entries = registry.entries()
      for (i in entries) {
        if (entries[i].type && entries[i].type !== 'unload') off(entries[i].element, entries[i].type)
      }
      win.detachEvent('onunload', cleanup)
      win.CollectGarbage && win.CollectGarbage()
    }
    win.attachEvent('onunload', cleanup)
  }

  // initialize selector engine to internal default (qSA or throw Error)
  setSelectorEngine()

  return bean
});

================================================
FILE: vendors/baron/js/bonzo.js
================================================
/*!
  * Bonzo: DOM Utility (c) Dustin Diaz 2012
  * https://github.com/ded/bonzo
  * License MIT
  */
(function (name, context, definition) {
  if (typeof module != 'undefined' && module.exports) module.exports = definition()
  else if (typeof define == 'function' && define.amd) define(definition)
  else context[name] = definition()
})('bonzo', this, function() {
  var win = window
    , doc = win.document
    , html = doc.documentElement
    , parentNode = 'parentNode'
    , specialAttributes = /^(checked|value|selected|disabled)$/i
    , specialTags = /^(select|fieldset|table|tbody|tfoot|td|tr|colgroup)$/i // tags that we have trouble inserting *into*
    , simpleScriptTagRe = /\s*<script +src=['"]([^'"]+)['"]>/
    , table = ['<table>', '</table>', 1]
    , td = ['<table><tbody><tr>', '</tr></tbody></table>', 3]
    , option = ['<select>', '</select>', 1]
    , noscope = ['_', '', 0, 1]
    , tagMap = { // tags that we have trouble *inserting*
          thead: table, tbody: table, tfoot: table, colgroup: table, caption: table
        , tr: ['<table><tbody>', '</tbody></table>', 2]
        , th: td , td: td
        , col: ['<table><colgroup>', '</colgroup></table>', 2]
        , fieldset: ['<form>', '</form>', 1]
        , legend: ['<form><fieldset>', '</fieldset></form>', 2]
        , option: option, optgroup: option
        , script: noscope, style: noscope, link: noscope, param: noscope, base: noscope
      }
    , stateAttributes = /^(checked|selected|disabled)$/
    , ie = /msie/i.test(navigator.userAgent)
    , hasClass, addClass, removeClass
    , uidMap = {}
    , uuids = 0
    , digit = /^-?[\d\.]+$/
    , dattr = /^data-(.+)$/
    , px = 'px'
    , setAttribute = 'setAttribute'
    , getAttribute = 'getAttribute'
    , byTag = 'getElementsByTagName'
    , features = function() {
        var e = doc.createElement('p')
        e.innerHTML = '<a href="#x">x</a><table style="float:left;"></table>'
        return {
          hrefExtended: e[byTag]('a')[0][getAttribute]('href') != '#x' // IE < 8
        , autoTbody: e[byTag]('tbody').length !== 0 // IE < 8
        , computedStyle: doc.defaultView && doc.defaultView.getComputedStyle
        , cssFloat: e[byTag]('table')[0].style.styleFloat ? 'styleFloat' : 'cssFloat'
        , transform: function () {
            var props = ['transform', 'webkitTransform', 'MozTransform', 'OTransform', 'msTransform'], i
            for (i = 0; i < props.length; i++) {
              if (props[i] in e.style) return props[i]
            }
          }()
        , classList: 'classList' in e
        , opasity: function () {
            return typeof doc.createElement('a').style.opacity !== 'undefined'
          }()
        }
      }()
    , trimReplace = /(^\s*|\s*$)/g
    , whitespaceRegex = /\s+/
    , toString = String.prototype.toString
    , unitless = { lineHeight: 1, zoom: 1, zIndex: 1, opacity: 1, boxFlex: 1, WebkitBoxFlex: 1, MozBoxFlex: 1 }
    , query = doc.querySelectorAll && function (selector) { return doc.querySelectorAll(selector) }
    , trim = String.prototype.trim ?
        function (s) {
          return s.trim()
        } :
        function (s) {
          return s.replace(trimReplace, '')
        }


  function isNode(node) {
    return node && node.nodeName && (node.nodeType == 1 || node.nodeType == 11)
  }


  function normalize(node, host, clone) {
    var i, l, ret
    if (typeof node == 'string') return bonzo.create(node)
    if (isNode(node)) node = [ node ]
    if (clone) {
      ret = [] // don't change original array
      for (i = 0, l = node.length; i < l; i++) ret[i] = cloneNode(host, node[i])
      return ret
    }
    return node
  }


  /**
   * @param {string} c a class name to test
   * @return {boolean}
   */
  function classReg(c) {
    return new RegExp("(^|\\s+)" + c + "(\\s+|$)")
  }


  /**
   * @param {Bonzo|Array} ar
   * @param {function(Object, number, (Bonzo|Array))} fn
   * @param {Object=} opt_scope
   * @param {boolean=} opt_rev
   * @return {Bonzo|Array}
   */
  function each(ar, fn, opt_scope, opt_rev) {
    var ind, i = 0, l = ar.length
    for (; i < l; i++) {
      ind = opt_rev ? ar.length - i - 1 : i
      fn.call(opt_scope || ar[ind], ar[ind], ind, ar)
    }
    return ar
  }


  /**
   * @param {Bonzo|Array} ar
   * @param {function(Object, number, (Bonzo|Array))} fn
   * @param {Object=} opt_scope
   * @return {Bonzo|Array}
   */
  function deepEach(ar, fn, opt_scope) {
    for (var i = 0, l = ar.length; i < l; i++) {
      if (isNode(ar[i])) {
        deepEach(ar[i].childNodes, fn, opt_scope)
        fn.call(opt_scope || ar[i], ar[i], i, ar)
      }
    }
    return ar
  }


  /**
   * @param {string} s
   * @return {string}
   */
  function camelize(s) {
    return s.replace(/-(.)/g, function (m, m1) {
      return m1.toUpperCase()
    })
  }


  /**
   * @param {string} s
   * @return {string}
   */
  function decamelize(s) {
    return s ? s.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase() : s
  }


  /**
   * @param {Element} el
   * @return {*}
   */
  function data(el) {
    el[getAttribute]('data-node-uid') || el[setAttribute]('data-node-uid', ++uuids)
    var uid = el[getAttribute]('data-node-uid')
    return uidMap[uid] || (uidMap[uid] = {})
  }


  /**
   * removes the data associated with an element
   * @param {Element} el
   */
  function clearData(el) {
    var uid = el[getAttribute]('data-node-uid')
    if (uid) delete uidMap[uid]
  }


  function dataValue(d) {
    var f
    try {
      return (d === null || d === undefined) ? undefined :
        d === 'true' ? true :
          d === 'false' ? false :
            d === 'null' ? null :
              (f = parseFloat(d)) == d ? f : d;
    } catch(e) {}
    return undefined
  }


  /**
   * @param {Bonzo|Array} ar
   * @param {function(Object, number, (Bonzo|Array))} fn
   * @param {Object=} opt_scope
   * @return {boolean} whether `some`thing was found
   */
  function some(ar, fn, opt_scope) {
    for (var i = 0, j = ar.length; i < j; ++i) if (fn.call(opt_scope || null, ar[i], i, ar)) return true
    return false
  }


  /**
   * this could be a giant enum of CSS properties
   * but in favor of file size sans-closure deadcode optimizations
   * we're just asking for any ol string
   * then it gets transformed into the appropriate style property for JS access
   * @param {string} p
   * @return {string}
   */
  function styleProperty(p) {
      (p == 'transform' && (p = features.transform)) ||
        (/^transform-?[Oo]rigin$/.test(p) && (p = features.transform + 'Origin')) ||
        (p == 'float' && (p = features.cssFloat))
      return p ? camelize(p) : null
  }

  var getStyle = features.computedStyle ?
    function (el, property) {
      var value = null
        , computed = doc.defaultView.getComputedStyle(el, '')
      computed && (value = computed[property])
      return el.style[property] || value
    } :

    (ie && html.currentStyle) ?

    /**
     * @param {Element} el
     * @param {string} property
     * @return {string|number}
     */
    function (el, property) {
      if (property == 'opacity' && !features.opasity) {
        var val = 100
        try {
          val = el['filters']['DXImageTransform.Microsoft.Alpha'].opacity
        } catch (e1) {
          try {
            val = el['filters']('alpha').opacity
          } catch (e2) {}
        }
        return val / 100
      }
      var value = el.currentStyle ? el.currentStyle[property] : null
      return el.style[property] || value
    } :

    function (el, property) {
      return el.style[property]
    }

  // this insert method is intense
  function insert(target, host, fn, rev) {
    var i = 0, self = host || this, r = []
      // target nodes could be a css selector if it's a string and a selector engine is present
      // otherwise, just use target
      , nodes = query && typeof target == 'string' && target.charAt(0) != '<' ? query(target) : target
    // normalize each node in case it's still a string and we need to create nodes on the fly
    each(normalize(nodes), function (t, j) {
      each(self, function (el) {
        fn(t, r[i++] = j > 0 ? cloneNode(self, el) : el)
      }, null, rev)
    }, this, rev)
    self.length = i
    each(r, function (e) {
      self[--i] = e
    }, null, !rev)
    return self
  }


  /**
   * sets an element to an explicit x/y position on the page
   * @param {Element} el
   * @param {?number} x
   * @param {?number} y
   */
  function xy(el, x, y) {
    var $el = bonzo(el)
      , style = $el.css('position')
      , offset = $el.offset()
      , rel = 'relative'
      , isRel = style == rel
      , delta = [parseInt($el.css('left'), 10), parseInt($el.css('top'), 10)]

    if (style == 'static') {
      $el.css('position', rel)
      style = rel
    }

    isNaN(delta[0]) && (delta[0] = isRel ? 0 : el.offsetLeft)
    isNaN(delta[1]) && (delta[1] = isRel ? 0 : el.offsetTop)

    x != null && (el.style.left = x - offset.left + delta[0] + px)
    y != null && (el.style.top = y - offset.top + delta[1] + px)

  }

  // classList support for class management
  // altho to be fair, the api sucks because it won't accept multiple classes at once
  if (features.classList) {
    hasClass = function (el, c) {
      return el.classList.contains(c)
    }
    addClass = function (el, c) {
      el.classList.add(c)
    }
    removeClass = function (el, c) {
      el.classList.remove(c)
    }
  }
  else {
    hasClass = function (el, c) {
      return classReg(c).test(el.className)
    }
    addClass = function (el, c) {
      el.className = trim(el.className + ' ' + c)
    }
    removeClass = function (el, c) {
      el.className = trim(el.className.replace(classReg(c), ' '))
    }
  }


  /**
   * this allows method calling for setting values
   *
   * @example
   * bonzo(elements).css('color', function (el) {
   *   return el.getAttribute('data-original-color')
   * })
   *
   * @param {Element} el
   * @param {function (Element)|string}
   * @return {string}
   */
  function setter(el, v) {
    return typeof v == 'function' ? v(el) : v
  }

  /**
   * @constructor
   * @param {Array.<Element>|Element|Node|string} elements
   */
  function Bonzo(elements) {
    this.length = 0
    if (elements) {
      elements = typeof elements !== 'string' &&
        !elements.nodeType &&
        typeof elements.length !== 'undefined' ?
          elements :
          [elements]
      this.length = elements.length
      for (var i = 0; i < elements.length; i++) this[i] = elements[i]
    }
  }

  Bonzo.prototype = {

      /**
       * @param {number} index
       * @return {Element|Node}
       */
      get: function (index) {
        return this[index] || null
      }

      // itetators
      /**
       * @param {function(Element|Node)} fn
       * @param {Object=} opt_scope
       * @return {Bonzo}
       */
    , each: function (fn, opt_scope) {
        return each(this, fn, opt_scope)
      }

      /**
       * @param {Function} fn
       * @param {Object=} opt_scope
       * @return {Bonzo}
       */
    , deepEach: function (fn, opt_scope) {
        return deepEach(this, fn, opt_scope)
      }


      /**
       * @param {Function} fn
       * @param {Function=} opt_reject
       * @return {Array}
       */
    , map: function (fn, opt_reject) {
        var m = [], n, i
        for (i = 0; i < this.length; i++) {
          n = fn.call(this, this[i], i)
          opt_reject ? (opt_reject(n) && m.push(n)) : m.push(n)
        }
        return m
      }

    // text and html inserters!

    /**
     * @param {string} h the HTML to insert
     * @param {boolean=} opt_text whether to set or get text content
     * @return {Bonzo|string}
     */
    , html: function (h, opt_text) {
        var method = opt_text
              ? html.textContent === undefined ? 'innerText' : 'textContent'
              : 'innerHTML'
          , that = this
          , append = function (el, i) {
              each(normalize(h, that, i), function (node) {
                el.appendChild(node)
              })
            }
          , updateElement = function (el, i) {
              try {
                if (opt_text || (typeof h == 'string' && !specialTags.test(el.tagName))) {
                  return el[method] = h
                }
              } catch (e) {}
              append(el, i)
            }
        return typeof h != 'undefined'
          ? this.empty().each(updateElement)
          : this[0] ? this[0][method] : ''
      }

      /**
       * @param {string=} opt_text the text to set, otherwise this is a getter
       * @return {Bonzo|string}
       */
    , text: function (opt_text) {
        return this.html(opt_text, true)
      }

      // more related insertion methods

      /**
       * @param {Bonzo|string|Element|Array} node
       * @return {Bonzo}
       */
    , append: function (node) {
        var that = this
        return this.each(function (el, i) {
          each(normalize(node, that, i), function (i) {
            el.appendChild(i)
          })
        })
      }


      /**
       * @param {Bonzo|string|Element|Array} node
       * @return {Bonzo}
       */
    , prepend: function (node) {
        var that = this
        return this.each(function (el, i) {
          var first = el.firstChild
          each(normalize(node, that, i), function (i) {
            el.insertBefore(i, first)
          })
        })
      }


      /**
       * @param {Bonzo|string|Element|Array} target the location for which you'll insert your new content
       * @param {Object=} opt_host an optional host scope (primarily used when integrated with Ender)
       * @return {Bonzo}
       */
    , appendTo: function (target, opt_host) {
        return insert.call(this, target, opt_host, function (t, el) {
          t.appendChild(el)
        })
      }


      /**
       * @param {Bonzo|string|Element|Array} target the location for which you'll insert your new content
       * @param {Object=} opt_host an optional host scope (primarily used when integrated with Ender)
       * @return {Bonzo}
       */
    , prependTo: function (target, opt_host) {
        return insert.call(this, target, opt_host, function (t, el) {
          t.insertBefore(el, t.firstChild)
        }, 1)
      }


      /**
       * @param {Bonzo|string|Element|Array} node
       * @return {Bonzo}
       */
    , before: function (node) {
        var that = this
        return this.each(function (el, i) {
          each(normalize(node, that, i), function (i) {
            el[parentNode].insertBefore(i, el)
          })
        })
      }


      /**
       * @param {Bonzo|string|Element|Array} node
       * @return {Bonzo}
       */
    , after: function (node) {
        var that = this
        return this.each(function (el, i) {
          each(normalize(node, that, i), function (i) {
            el[parentNode].insertBefore(i, el.nextSibling)
          }, null, 1)
        })
      }


      /**
       * @param {Bonzo|string|Element|Array} target the location for which you'll insert your new content
       * @param {Object=} opt_host an optional host scope (primarily used when integrated with Ender)
       * @return {Bonzo}
       */
    , insertBefore: function (target, opt_host) {
        return insert.call(this, target, opt_host, function (t, el) {
          t[parentNode].insertBefore(el, t)
        })
      }


      /**
       * @param {Bonzo|string|Element|Array} target the location for which you'll insert your new content
       * @param {Object=} opt_host an optional host scope (primarily used when integrated with Ender)
       * @return {Bonzo}
       */
    , insertAfter: function (target, opt_host) {
        return insert.call(this, target, opt_host, function (t, el) {
          var sibling = t.nextSibling
          sibling ?
            t[parentNode].insertBefore(el, sibling) :
            t[parentNode].appendChild(el)
        }, 1)
      }


      /**
       * @param {Bonzo|string|Element|Array} node
       * @return {Bonzo}
       */
    , replaceWith: function (node) {
        bonzo(normalize(node)).insertAfter(this)
        return this.remove()
      }

      // class management

      /**
       * @param {string} c
       * @return {Bonzo}
       */
    , addClass: function (c) {
        c = toString.call(c).split(whitespaceRegex)
        return this.each(function (el) {
          // we `each` here so you can do $el.addClass('foo bar')
          each(c, function (c) {
            if (c && !hasClass(el, setter(el, c)))
              addClass(el, setter(el, c))
          })
        })
      }


      /**
       * @param {string} c
       * @return {Bonzo}
       */
    , removeClass: function (c) {
        c = toString.call(c).split(whitespaceRegex)
        return this.each(function (el) {
          each(c, function (c) {
            if (c && hasClass(el, setter(el, c)))
              removeClass(el, setter(el, c))
          })
        })
      }


      /**
       * @param {string} c
       * @return {boolean}
       */
    , hasClass: function (c) {
        c = toString.call(c).split(whitespaceRegex)
        return some(this, function (el) {
          return some(c, function (c) {
            return c && hasClass(el, c)
          })
        })
      }


      /**
       * @param {string} c classname to toggle
       * @param {boolean=} opt_condition whether to add or remove the class straight away
       * @return {Bonzo}
       */
    , toggleClass: function (c, opt_condition) {
        c = toString.call(c).split(whitespaceRegex)
        return this.each(function (el) {
          each(c, function (c) {
            if (c) {
              typeof opt_condition !== 'undefined' ?
                opt_condition ? !hasClass(el, c) && addClass(el, c) : removeClass(el, c) :
                hasClass(el, c) ? removeClass(el, c) : addClass(el, c)
            }
          })
        })
      }

      // display togglers

      /**
       * @param {string=} opt_type useful to set back to anything other than an empty string
       * @return {Bonzo}
       */
    , show: function (opt_type) {
        opt_type = typeof opt_type == 'string' ? opt_type : ''
        return this.each(function (el) {
          el.style.display = opt_type
        })
      }


      /**
       * @return {Bonzo}
       */
    , hide: function () {
        return this.each(function (el) {
          el.style.display = 'none'
        })
      }


      /**
       * @param {Function=} opt_callback
       * @param {string=} opt_type
       * @return {Bonzo}
       */
    , toggle: function (opt_callback, opt_type) {
        opt_type = typeof opt_type == 'string' ? opt_type : '';
        typeof opt_callback != 'function' && (opt_callback = null)
        return this.each(function (el) {
          el.style.display = (el.offsetWidth || el.offsetHeight) ? 'none' : opt_type;
          opt_callback && opt_callback.call(el)
        })
      }


      // DOM Walkers & getters

      /**
       * @return {Element|Node}
       */
    , first: function () {
        return bonzo(this.length ? this[0] : [])
      }


      /**
       * @return {Element|Node}
       */
    , last: function () {
        return bonzo(this.length ? this[this.length - 1] : [])
      }


      /**
       * @return {Element|Node}
       */
    , next: function () {
        return this.related('nextSibling')
      }


      /**
       * @return {Element|Node}
       */
    , previous: function () {
        return this.related('previousSibling')
      }


      /**
       * @return {Element|Node}
       */
    , parent: function() {
        return this.related(parentNode)
      }


      /**
       * @private
       * @param {string} method the directional DOM method
       * @return {Element|Node}
       */
    , related: function (method) {
        return this.map(
          function (el) {
            el = el[method]
            while (el && el.nodeType !== 1) {
              el = el[method]
            }
            return el || 0
          },
          function (el) {
            return el
          }
        )
      }


      /**
       * @return {Bonzo}
       */
    , focus: function () {
        this.length && this[0].focus()
        return this
      }


      /**
       * @return {Bonzo}
       */
    , blur: function () {
        this.length && this[0].blur()
        return this
      }

      // style getter setter & related methods

      /**
       * @param {Object|string} o
       * @param {string=} opt_v
       * @return {Bonzo|string}
       */
    , css: function (o, opt_v) {
        var p, iter = o
        // is this a request for just getting a style?
        if (opt_v === undefined && typeof o == 'string') {
          // repurpose 'v'
          opt_v = this[0]
          if (!opt_v) return null
          if (opt_v === doc || opt_v === win) {
            p = (opt_v === doc) ? bonzo.doc() : bonzo.viewport()
            return o == 'width' ? p.width : o == 'height' ? p.height : ''
          }
          return (o = styleProperty(o)) ? getStyle(opt_v, o) : null
        }

        if (typeof o == 'string') {
          iter = {}
          iter[o] = opt_v
        }

        if (ie && iter.opacity) {
          // oh this 'ol gamut
          iter.filter = 'alpha(opacity=' + (iter.opacity * 100) + ')'
          // give it layout
          iter.zoom = o.zoom || 1;
          delete iter.opacity;
        }

        function fn(el, p, v) {
          for (var k in iter) {
            if (iter.hasOwnProperty(k)) {
              v = iter[k];
              // change "5" to "5px" - unless you're line-height, which is allowed
              (p = styleProperty(k)) && digit.test(v) && !(p in unitless) && (v += px)
              try { el.style[p] = setter(el, v) } catch(e) {}
            }
          }
        }
        return this.each(fn)
      }


      /**
       * @param {number=} opt_x
       * @param {number=} opt_y
       * @return {Bonzo|number}
       */
    , offset: function (opt_x, opt_y) {
        if (opt_x && typeof opt_x == 'object' && (typeof opt_x.top == 'number' || typeof opt_x.left == 'number')) {
          return this.each(function (el) {
            xy(el, opt_x.left, opt_x.top)
          })
        } else if (typeof opt_x == 'number' || typeof opt_y == 'number') {
          return this.each(function (el) {
            xy(el, opt_x, opt_y)
          })
        }
        if (!this[0]) return {
            top: 0
          , left: 0
          , height: 0
          , width: 0
        }
        var el = this[0]
          , de = el.ownerDocument.documentElement
          , bcr = el.getBoundingClientRect()
          , scroll = getWindowScroll()
          , width = el.offsetWidth
          , height = el.offsetHeight
          , top = bcr.top + scroll.y - Math.max(0, de && de.clientTop, doc.body.clientTop)
          , left = bcr.left + scroll.x - Math.max(0, de && de.clientLeft, doc.body.clientLeft)

        return {
            top: top
          , left: left
          , height: height
          , width: width
        }
      }


      /**
       * @return {number}
       */
    , dim: function () {
        if (!this.length) return { height: 0, width: 0 }
        var el = this[0]
          , de = el.nodeType == 9 && el.documentElement // document
          , orig = !de && !!el.style && !el.offsetWidth && !el.offsetHeight ?
             // el isn't visible, can't be measured properly, so fix that
             function (t) {
               var s = {
                   position: el.style.position || ''
                 , visibility: el.style.visibility || ''
                 , display: el.style.display || ''
               }
               t.first().css({
                   position: 'absolute'
                 , visibility: 'hidden'
                 , display: 'block'
               })
               return s
            }(this) : null
          , width = de
              ? Math.max(el.body.scrollWidth, el.body.offsetWidth, de.scrollWidth, de.offsetWidth, de.clientWidth)
              : el.offsetWidth
          , height = de
              ? Math.max(el.body.scrollHeight, el.body.offsetHeight, de.scrollHeight, de.offsetHeight, de.clientHeight)
              : el.offsetHeight

        orig && this.first().css(orig)
        return {
            height: height
          , width: width
        }
      }

      // attributes are hard. go shopping

      /**
       * @param {string} k an attribute to get or set
       * @param {string=} opt_v the value to set
       * @return {Bonzo|string}
       */
    , attr: function (k, opt_v) {
        var el = this[0]
        if (typeof k != 'string' && !(k instanceof String)) {
          for (var n in k) {
            k.hasOwnProperty(n) && this.attr(n, k[n])
          }
          return this
        }
        return typeof opt_v == 'undefined' ?
          !el ? null : specialAttributes.test(k) ?
            stateAttributes.test(k) && typeof el[k] == 'string' ?
              true : el[k] : (k == 'href' || k =='src') && features.hrefExtended ?
                el[getAttribute](k, 2) : el[getAttribute](k) :
          this.each(function (el) {
            specialAttributes.test(k) ? (el[k] = setter(el, opt_v)) : el[setAttribute](k, setter(el, opt_v))
          })
      }


      /**
       * @param {string} k
       * @return {Bonzo}
       */
    , removeAttr: function (k) {
        return this.each(function (el) {
          stateAttributes.test(k) ? (el[k] = false) : el.removeAttribute(k)
        })
      }


      /**
       * @param {string=} opt_s
       * @return {Bonzo|string}
       */
    , val: function (s) {
        return (typeof s == 'string') ?
          this.attr('value', s) :
          this.length ? this[0].value : null
      }

      // use with care and knowledge. this data() method uses data attributes on the DOM nodes
      // to do this differently costs a lot more code. c'est la vie
      /**
       * @param {string|Object=} opt_k the key for which to get or set data
       * @param {Object=} opt_v
       * @return {Bonzo|Object}
       */
    , data: function (opt_k, opt_v) {
        var el = this[0], o, m
        if (typeof opt_v === 'undefined') {
          if (!el) return null
          o = data(el)
          if (typeof opt_k === 'undefined') {
            each(el.attributes, function (a) {
              (m = ('' + a.name).match(dattr)) && (o[camelize(m[1])] = dataValue(a.value))
            })
            return o
          } else {
            if (typeof o[opt_k] === 'undefined')
              o[opt_k] = dataValue(this.attr('data-' + decamelize(opt_k)))
            return o[opt_k]
          }
        } else {
          return this.each(function (el) { data(el)[opt_k] = opt_v })
        }
      }

      // DOM detachment & related

      /**
       * @return {Bonzo}
       */
    , remove: function () {
        this.deepEach(clearData)
        return this.detach()
      }


      /**
       * @return {Bonzo}
       */
    , empty: function () {
        return this.each(function (el) {
          deepEach(el.childNodes, clearData)

          while (el.firstChild) {
            el.removeChild(el.firstChild)
          }
        })
      }


      /**
       * @return {Bonzo}
       */
    , detach: function () {
        return this.each(function (el) {
          el[parentNode] && el[parentNode].removeChild(el)
        })
      }

      // who uses a mouse anyway? oh right.

      /**
       * @param {number} y
       */
    , scrollTop: function (y) {
        return scroll.call(this, null, y, 'y')
      }


      /**
       * @param {number} x
       */
    , scrollLeft: function (x) {
        return scroll.call(this, x, null, 'x')
      }

  }


  function cloneNode(host, el) {
    var c = el.cloneNode(true)
      , cloneElems
      , elElems

    // check for existence of an event cloner
    // preferably https://github.com/fat/bean
    // otherwise Bonzo won't do this for you
    if (host.$ && typeof host.cloneEvents == 'function') {
      host.$(c).cloneEvents(el)

      // clone events from every child node
      cloneElems = host.$(c).find('*')
      elElems = host.$(el).find('*')

      for (var i = 0; i < elElems.length; i++)
        host.$(cloneElems[i]).cloneEvents(elElems[i])
    }
    return c
  }

  function scroll(x, y, type) {
    var el = this[0]
    if (!el) return this
    if (x == null && y == null) {
      return (isBody(el) ? getWindowScroll() : { x: el.scrollLeft, y: el.scrollTop })[type]
    }
    if (isBody(el)) {
      win.scrollTo(x, y)
    } else {
      x != null && (el.scrollLeft = x)
      y != null && (el.scrollTop = y)
    }
    return this
  }

  function isBody(element) {
    return element === win || (/^(?:body|html)$/i).test(element.tagName)
  }

  function getWindowScroll() {
    return { x: win.pageXOffset || html.scrollLeft, y: win.pageYOffset || html.scrollTop }
  }

  function createScriptFromHtml(html) {
    var scriptEl = document.createElement('script')
      , matches = html.match(simpleScriptTagRe)
    scriptEl.src = matches[1]
    return scriptEl
  }

  /**
   * @param {Array.<Element>|Element|Node|string} els
   * @return {Bonzo}
   */
  function bonzo(els) {
    return new Bonzo(els)
  }

  bonzo.setQueryEngine = function (q) {
    query = q;
    delete bonzo.setQueryEngine
  }

  bonzo.aug = function (o, target) {
    // for those standalone bonzo users. this love is for you.
    for (var k in o) {
      o.hasOwnProperty(k) && ((target || Bonzo.prototype)[k] = o[k])
    }
  }

  bonzo.create = function (node) {
    // hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
    return typeof node == 'string' && node !== '' ?
      function () {
        if (simpleScriptTagRe.test(node)) return [createScriptFromHtml(node)]
        var tag = node.match(/^\s*<([^\s>]+)/)
          , el = doc.createElement('div')
          , els = []
          , p = tag ? tagMap[tag[1].toLowerCase()] : null
          , dep = p ? p[2] + 1 : 1
          , ns = p && p[3]
          , pn = parentNode
          , tb = features.autoTbody && p && p[0] == '<table>' && !(/<tbody/i).test(node)

        el.innerHTML = p ? (p[0] + node + p[1]) : node
        while (dep--) el = el.firstChild
        // for IE NoScope, we may insert cruft at the begining just to get it to work
        if (ns && el && el.nodeType !== 1) el = el.nextSibling
        do {
          // tbody special case for IE<8, creates tbody on any empty table
          // we don't want it if we're just after a <thead>, <caption>, etc.
          if ((!tag || el.nodeType == 1) && (!tb || (el.tagName && el.tagName != 'TBODY'))) {
            els.push(el)
          }
        } while (el = el.nextSibling)
        // IE < 9 gives us a parentNode which messes up insert() check for cloning
        // `dep` > 1 can also cause problems with the insert() check (must do this last)
        each(els, function(el) { el[pn] && el[pn].removeChild(el) })
        return els
      }() : isNode(node) ? [node.cloneNode(true)] : []
  }

  bonzo.doc = function () {
    var vp = bonzo.viewport()
    return {
        width: Math.max(doc.body.scrollWidth, html.scrollWidth, vp.width)
      , height: Math.max(doc.body.scrollHeight, html.scrollHeight, vp.height)
    }
  }

  bonzo.firstChild = function (el) {
    for (var c = el.childNodes, i = 0, j = (c && c.length) || 0, e; i < j; i++) {
      if (c[i].nodeType === 1) e = c[j = i]
    }
    return e
  }

  bonzo.viewport = function () {
    return {
        width: ie ? html.clientWidth : self.innerWidth
      , height: ie ? html.clientHeight : self.innerHeight
    }
  }

  bonzo.isAncestor = 'compareDocumentPosition' in html ?
    function (container, element) {
      return (container.compareDocumentPosition(element) & 16) == 16
    } : 'contains' in html ?
    function (container, element) {
      return container !== element && container.contains(element);
    } :
    function (container, element) {
      while (element = element[parentNode]) {
        if (element === container) {
          return true
        }
      }
      return false
    }

  return bonzo
}); // the only line we care about using a semi-colon. placed here for concatenation tools

================================================
FILE: vendors/baron/js/jquery-1.9.0.js
================================================
/*!
 * jQuery JavaScript Library v1.9.0
 * http://jquery.com/
 *
 * Includes Sizzle.js
 * http://sizzlejs.com/
 *
 * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
 * Released under the MIT license
 * http://jquery.org/license
 *
 * Date: 2013-1-14
 */
(function( window, undefined ) {
"use strict";
var
	// A central reference to the root jQuery(document)
	rootjQuery,

	// The deferred used on DOM ready
	readyList,

	// Use the correct document accordingly with window argument (sandbox)
	document = window.document,
	location = window.location,

	// Map over jQuery in case of overwrite
	_jQuery = window.jQuery,

	// Map over the $ in case of overwrite
	_$ = window.$,

	// [[Class]] -> type pairs
	class2type = {},

	// List of deleted data cache ids, so we can reuse them
	core_deletedIds = [],

	core_version = "1.9.0",

	// Save a reference to some core methods
	core_concat = core_deletedIds.concat,
	core_push = core_deletedIds.push,
	core_slice = core_deletedIds.slice,
	core_indexOf = core_deletedIds.indexOf,
	core_toString = class2type.toString,
	core_hasOwn = class2type.hasOwnProperty,
	core_trim = core_version.trim,

	// Define a local copy of jQuery
	jQuery = function( selector, context ) {
		// The jQuery object is actually just the init constructor 'enhanced'
		return new jQuery.fn.init( selector, context, rootjQuery );
	},

	// Used for matching numbers
	core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,

	// Used for splitting on whitespace
	core_rnotwhite = /\S+/g,

	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,

	// A simple way to check for HTML strings
	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
	// Strict HTML recognition (#11290: must start with <)
	rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,

	// Match a standalone tag
	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,

	// JSON RegExp
	rvalidchars = /^[\],:{}\s]*$/,
	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,

	// Matches dashed string for camelizing
	rmsPrefix = /^-ms-/,
	rdashAlpha = /-([\da-z])/gi,

	// Used by jQuery.camelCase as callback to replace()
	fcamelCase = function( all, letter ) {
		return letter.toUpperCase();
	},

	// The ready event handler and self cleanup method
	DOMContentLoaded = function() {
		if ( document.addEventListener ) {
			document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
			jQuery.ready();
		} else if ( document.readyState === "complete" ) {
			// we're here because readyState === "complete" in oldIE
			// which is good enough for us to call the dom ready!
			document.detachEvent( "onreadystatechange", DOMContentLoaded );
			jQuery.ready();
		}
	};

jQuery.fn = jQuery.prototype = {
	// The current version of jQuery being used
	jquery: core_version,

	constructor: jQuery,
	init: function( selector, context, rootjQuery ) {
		var match, elem;

		// HANDLE: $(""), $(null), $(undefined), $(false)
		if ( !selector ) {
			return this;
		}

		// Handle HTML strings
		if ( typeof selector === "string" ) {
			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
				// Assume that strings that start and end with <> are HTML and skip the regex check
				match = [ null, selector, null ];

			} else {
				match = rquickExpr.exec( selector );
			}

			// Match html or make sure no context is specified for #id
			if ( match && (match[1] || !context) ) {

				// HANDLE: $(html) -> $(array)
				if ( match[1] ) {
					context = context instanceof jQuery ? context[0] : context;

					// scripts is true for back-compat
					jQuery.merge( this, jQuery.parseHTML(
						match[1],
						context && context.nodeType ? context.ownerDocument || context : document,
						true
					) );

					// HANDLE: $(html, props)
					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
						for ( match in context ) {
							// Properties of context are called as methods if possible
							if ( jQuery.isFunction( this[ match ] ) ) {
								this[ match ]( context[ match ] );

							// ...and otherwise set as attributes
							} else {
								this.attr( match, context[ match ] );
							}
						}
					}

					return this;

				// HANDLE: $(#id)
				} else {
					elem = document.getElementById( match[2] );

					// Check parentNode to catch when Blackberry 4.6 returns
					// nodes that are no longer in the document #6963
					if ( elem && elem.parentNode ) {
						// Handle the case where IE and Opera return items
						// by name instead of ID
						if ( elem.id !== match[2] ) {
							return rootjQuery.find( selector );
						}

						// Otherwise, we inject the element directly into the jQuery object
						this.length = 1;
						this[0] = elem;
					}

					this.context = document;
					this.selector = selector;
					return this;
				}

			// HANDLE: $(expr, $(...))
			} else if ( !context || context.jquery ) {
				return ( context || rootjQuery ).find( selector );

			// HANDLE: $(expr, context)
			// (which is just equivalent to: $(context).find(expr)
			} else {
				return this.constructor( context ).find( selector );
			}

		// HANDLE: $(DOMElement)
		} else if ( selector.nodeType ) {
			this.context = this[0] = selector;
			this.length = 1;
			return this;

		// HANDLE: $(function)
		// Shortcut for document ready
		} else if ( jQuery.isFunction( selector ) ) {
			return rootjQuery.ready( selector );
		}

		if ( selector.selector !== undefined ) {
			this.selector = selector.selector;
			this.context = selector.context;
		}

		return jQuery.makeArray( selector, this );
	},

	// Start with an empty selector
	selector: "",

	// The default length of a jQuery object is 0
	length: 0,

	// The number of elements contained in the matched element set
	size: function() {
		return this.length;
	},

	toArray: function() {
		return core_slice.call( this );
	},

	// Get the Nth element in the matched element set OR
	// Get the whole matched element set as a clean array
	get: function( num ) {
		return num == null ?

			// Return a 'clean' array
			this.toArray() :

			// Return just the object
			( num < 0 ? this[ this.length + num ] : this[ num ] );
	},

	// Take an array of elements and push it onto the stack
	// (returning the new matched element set)
	pushStack: function( elems ) {

		// Build a new jQuery matched element set
		var ret = jQuery.merge( this.constructor(), elems );

		// Add the old object onto the stack (as a reference)
		ret.prevObject = this;
		ret.context = this.context;

		// Return the newly-formed element set
		return ret;
	},

	// Execute a callback for every element in the matched set.
	// (You can seed the arguments with an array of args, but this is
	// only used internally.)
	each: function( callback, args ) {
		return jQuery.each( this, callback, args );
	},

	ready: function( fn ) {
		// Add the callback
		jQuery.ready.promise().done( fn );

		return this;
	},

	slice: function() {
		return this.pushStack( core_slice.apply( this, arguments ) );
	},

	first: function() {
		return this.eq( 0 );
	},

	last: function() {
		return this.eq( -1 );
	},

	eq: function( i ) {
		var len = this.length,
			j = +i + ( i < 0 ? len : 0 );
		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
	},

	map: function( callback ) {
		return this.pushStack( jQuery.map(this, function( elem, i ) {
			return callback.call( elem, i, elem );
		}));
	},

	end: function() {
		return this.prevObject || this.constructor(null);
	},

	// For internal use only.
	// Behaves like an Array's method, not like a jQuery method.
	push: core_push,
	sort: [].sort,
	splice: [].splice
};

// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn;

jQuery.extend = jQuery.fn.extend = function() {
	var options, name, src, copy, copyIsArray, clone,
		target = arguments[0] || {},
		i = 1,
		length = arguments.length,
		deep = false;

	// Handle a deep copy situation
	if ( typeof target === "boolean" ) {
		deep = target;
		target = arguments[1] || {};
		// skip the boolean and the target
		i = 2;
	}

	// Handle case when target is a string or something (possible in deep copy)
	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
		target = {};
	}

	// extend jQuery itself if only one argument is passed
	if ( length === i ) {
		target = this;
		--i;
	}

	for ( ; i < length; i++ ) {
		// Only deal with non-null/undefined values
		if ( (options = arguments[ i ]) != null ) {
			// Extend the base object
			for ( name in options ) {
				src = target[ name ];
				copy = options[ name ];

				// Prevent never-ending loop
				if ( target === copy ) {
					continue;
				}

				// Recurse if we're merging plain objects or arrays
				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
					if ( copyIsArray ) {
						copyIsArray = false;
						clone = src && jQuery.isArray(src) ? src : [];

					} else {
						clone = src && jQuery.isPlainObject(src) ? src : {};
					}

					// Never move original objects, clone them
					target[ name ] = jQuery.extend( deep, clone, copy );

				// Don't bring in undefined values
				} else if ( copy !== undefined ) {
					target[ name ] = copy;
				}
			}
		}
	}

	// Return the modified object
	return target;
};

jQuery.extend({
	noConflict: function( deep ) {
		if ( window.$ === jQuery ) {
			window.$ = _$;
		}

		if ( deep && window.jQuery === jQuery ) {
			window.jQuery = _jQuery;
		}

		return jQuery;
	},

	// Is the DOM ready to be used? Set to true once it occurs.
	isReady: false,

	// A counter to track how many items to wait for before
	// the ready event fires. See #6781
	readyWait: 1,

	// Hold (or release) the ready event
	holdReady: function( hold ) {
		if ( hold ) {
			jQuery.readyWait++;
		} else {
			jQuery.ready( true );
		}
	},

	// Handle when the DOM is ready
	ready: function( wait ) {

		// Abort if there are pending holds or we're already ready
		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
			return;
		}

		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
		if ( !document.body ) {
			return setTimeout( jQuery.ready );
		}

		// Remember that the DOM is ready
		jQuery.isReady = true;

		// If a normal DOM Ready event fired, decrement, and wait if need be
		if ( wait !== true && --jQuery.readyWait > 0 ) {
			return;
		}

		// If there are functions bound, to execute
		readyList.resolveWith( document, [ jQuery ] );

		// Trigger any bound ready events
		if ( jQuery.fn.trigger ) {
			jQuery( document ).trigger("ready").off("ready");
		}
	},

	// See test/unit/core.js for details concerning isFunction.
	// Since version 1.3, DOM methods and functions like alert
	// aren't supported. They return false on IE (#2968).
	isFunction: function( obj ) {
		return jQuery.type(obj) === "function";
	},

	isArray: Array.isArray || function( obj ) {
		return jQuery.type(obj) === "array";
	},

	isWindow: function( obj ) {
		return obj != null && obj == obj.window;
	},

	isNumeric: function( obj ) {
		return !isNaN( parseFloat(obj) ) && isFinite( obj );
	},

	type: function( obj ) {
		if ( obj == null ) {
			return String( obj );
		}
		return typeof obj === "object" || typeof obj === "function" ?
			class2type[ core_toString.call(obj) ] || "object" :
			typeof obj;
	},

	isPlainObject: function( obj ) {
		// Must be an Object.
		// Because of IE, we also have to check the presence of the constructor property.
		// Make sure that DOM nodes and window objects don't pass through, as well
		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
			return false;
		}

		try {
			// Not own constructor property must be Object
			if ( obj.constructor &&
				!core_hasOwn.call(obj, "constructor") &&
				!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
				return false;
			}
		} catch ( e ) {
			// IE8,9 Will throw exceptions on certain host objects #9897
			return false;
		}

		// Own properties are enumerated firstly, so to speed up,
		// if last one is own, then all properties are own.

		var key;
		for ( key in obj ) {}

		return key === undefined || core_hasOwn.call( obj, key );
	},

	isEmptyObject: function( obj ) {
		var name;
		for ( name in obj ) {
			return false;
		}
		return true;
	},

	error: function( msg ) {
		throw new Error( msg );
	},

	// data: string of html
	// context (optional): If specified, the fragment will be created in this context, defaults to document
	// keepScripts (optional): If true, will include scripts passed in the html string
	parseHTML: function( data, context, keepScripts ) {
		if ( !data || typeof data !== "string" ) {
			return null;
		}
		if ( typeof context === "boolean" ) {
			keepScripts = context;
			context = false;
		}
		context = context || document;

		var parsed = rsingleTag.exec( data ),
			scripts = !keepScripts && [];

		// Single tag
		if ( parsed ) {
			return [ context.createElement( parsed[1] ) ];
		}

		parsed = jQuery.buildFragment( [ data ], context, scripts );
		if ( scripts ) {
			jQuery( scripts ).remove();
		}
		return jQuery.merge( [], parsed.childNodes );
	},

	parseJSON: function( data ) {
		// Attempt to parse using the native JSON parser first
		if ( window.JSON && window.JSON.parse ) {
			return window.JSON.parse( data );
		}

		if ( data === null ) {
			return data;
		}

		if ( typeof data === "string" ) {

			// Make sure leading/trailing whitespace is removed (IE can't handle it)
			data = jQuery.trim( data );

			if ( data ) {
				// Make sure the incoming data is actual JSON
				// Logic borrowed from http://json.org/json2.js
				if ( rvalidchars.test( data.replace( rvalidescape, "@" )
					.replace( rvalidtokens, "]" )
					.replace( rvalidbraces, "")) ) {

					return ( new Function( "return " + data ) )();
				}
			}
		}

		jQuery.error( "Invalid JSON: " + data );
	},

	// Cross-browser xml parsing
	parseXML: function( data ) {
		var xml, tmp;
		if ( !data || typeof data !== "string" ) {
			return null;
		}
		try {
			if ( window.DOMParser ) { // Standard
				tmp = new DOMParser();
				xml = tmp.parseFromString( data , "text/xml" );
			} else { // IE
				xml = new ActiveXObject( "Microsoft.XMLDOM" );
				xml.async = "false";
				xml.loadXML( data );
			}
		} catch( e ) {
			xml = undefined;
		}
		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
			jQuery.error( "Invalid XML: " + data );
		}
		return xml;
	},

	noop: function() {},

	// Evaluates a script in a global context
	// Workarounds based on findings by Jim Driscoll
	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
	globalEval: function( data ) {
		if ( data && jQuery.trim( data ) ) {
			// We use execScript on Internet Explorer
			// We use an anonymous function so that context is window
			// rather than jQuery in Firefox
			( window.execScript || function( data ) {
				window[ "eval" ].call( window, data );
			} )( data );
		}
	},

	// Convert dashed to camelCase; used by the css and data modules
	// Microsoft forgot to hump their vendor prefix (#9572)
	camelCase: function( string ) {
		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
	},

	nodeName: function( elem, name ) {
		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
	},

	// args is for internal usage only
	each: function( obj, callback, args ) {
		var value,
			i = 0,
			length = obj.length,
			isArray = isArraylike( obj );

		if ( args ) {
			if ( isArray ) {
				for ( ; i < length; i++ ) {
					value = callback.apply( obj[ i ], args );

					if ( value === false ) {
						break;
					}
				}
			} else {
				for ( i in obj ) {
					value = callback.apply( obj[ i ], args );

					if ( value === false ) {
						break;
					}
				}
			}

		// A special, fast, case for the most common use of each
		} else {
			if ( isArray ) {
				for ( ; i < length; i++ ) {
					value = callback.call( obj[ i ], i, obj[ i ] );

					if ( value === false ) {
						break;
					}
				}
			} else {
				for ( i in obj ) {
					value = callback.call( obj[ i ], i, obj[ i ] );

					if ( value === false ) {
						break;
					}
				}
			}
		}

		return obj;
	},

	// Use native String.trim function wherever possible
	trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
		function( text ) {
			return text == null ?
				"" :
				core_trim.call( text );
		} :

		// Otherwise use our own trimming functionality
		function( text ) {
			return text == null ?
				"" :
				( text + "" ).replace( rtrim, "" );
		},

	// results is for internal usage only
	makeArray: function( arr, results ) {
		var ret = results || [];

		if ( arr != null ) {
			if ( isArraylike( Object(arr) ) ) {
				jQuery.merge( ret,
					typeof arr === "string" ?
					[ arr ] : arr
				);
			} else {
				core_push.call( ret, arr );
			}
		}

		return ret;
	},

	inArray: function( elem, arr, i ) {
		var len;

		if ( arr ) {
			if ( core_indexOf ) {
				return core_indexOf.call( arr, elem, i );
			}

			len = arr.length;
			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;

			for ( ; i < len; i++ ) {
				// Skip accessing in sparse arrays
				if ( i in arr && arr[ i ] === elem ) {
					return i;
				}
			}
		}

		return -1;
	},

	merge: function( first, second ) {
		var l = second.length,
			i = first.length,
			j = 0;

		if ( typeof l === "number" ) {
			for ( ; j < l; j++ ) {
				first[ i++ ] = second[ j ];
			}
		} else {
			while ( second[j] !== undefined ) {
				first[ i++ ] = second[ j++ ];
			}
		}

		first.length = i;

		return first;
	},

	grep: function( elems, callback, inv ) {
		var retVal,
			ret = [],
			i = 0,
			length = elems.length;
		inv = !!inv;

		// Go through the array, only saving the items
		// that pass the validator function
		for ( ; i < length; i++ ) {
			retVal = !!callback( elems[ i ], i );
			if ( inv !== retVal ) {
				ret.push( elems[ i ] );
			}
		}

		return ret;
	},

	// arg is for internal usage only
	map: function( elems, callback, arg ) {
		var value,
			i = 0,
			length = elems.length,
			isArray = isArraylike( elems ),
			ret = [];

		// Go through the array, translating each of the items to their
		if ( isArray ) {
			for ( ; i < length; i++ ) {
				value = callback( elems[ i ], i, arg );

				if ( value != null ) {
					ret[ ret.length ] = value;
				}
			}

		// Go through every key on the object,
		} else {
			for ( i in elems ) {
				value = callback( elems[ i ], i, arg );

				if ( value != null ) {
					ret[ ret.length ] = value;
				}
			}
		}

		// Flatten any nested arrays
		return core_concat.apply( [], ret );
	},

	// A global GUID counter for objects
	guid: 1,

	// Bind a function to a context, optionally partially applying any
	// arguments.
	proxy: function( fn, context ) {
		var tmp, args, proxy;

		if ( typeof context === "string" ) {
			tmp = fn[ context ];
			context = fn;
			fn = tmp;
		}

		// Quick check to determine if target is callable, in the spec
		// this throws a TypeError, but we will just return undefined.
		if ( !jQuery.isFunction( fn ) ) {
			return undefined;
		}

		// Simulated bind
		args = core_slice.call( arguments, 2 );
		proxy = function() {
			return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );
		};

		// Set the guid of unique handler to the same of original handler, so it can be removed
		proxy.guid = fn.guid = fn.guid || jQuery.guid++;

		return proxy;
	},

	// Multifunctional method to get and set values of a collection
	// The value/s can optionally be executed if it's a function
	access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
		var i = 0,
			length = elems.length,
			bulk = key == null;

		// Sets many values
		if ( jQuery.type( key ) === "object" ) {
			chainable = true;
			for ( i in key ) {
				jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
			}

		// Sets one value
		} else if ( value !== undefined ) {
			chainable = true;

			if ( !jQuery.isFunction( value ) ) {
				raw = true;
			}

			if ( bulk ) {
				// Bulk operations run against the entire set
				if ( raw ) {
					fn.call( elems, value );
					fn = null;

				// ...except when executing function values
				} else {
					bulk = fn;
					fn = function( elem, key, value ) {
						return bulk.call( jQuery( elem ), value );
					};
				}
			}

			if ( fn ) {
				for ( ; i < length; i++ ) {
					fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
				}
			}
		}

		return chainable ?
			elems :

			// Gets
			bulk ?
				fn.call( elems ) :
				length ? fn( elems[0], key ) : emptyGet;
	},

	now: function() {
		return ( new Date() ).getTime();
	}
});

jQuery.ready.promise = function( obj ) {
	if ( !readyList ) {

		readyList = jQuery.Deferred();

		// Catch cases where $(document).ready() is called after the browser event has already occurred.
		// we once tried to use readyState "interactive" here, but it caused issues like the one
		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
		if ( document.readyState === "complete" ) {
			// Handle it asynchronously to allow scripts the opportunity to delay ready
			setTimeout( jQuery.ready );

		// Standards-based browsers support DOMContentLoaded
		} else if ( document.addEventListener ) {
			// Use the handy event callback
			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );

			// A fallback to window.onload, that will always work
			window.addEventListener( "load", jQuery.ready, false );

		// If IE event model is used
		} else {
			// Ensure firing before onload, maybe late but safe also for iframes
			document.attachEvent( "onreadystatechange", DOMContentLoaded );

			// A fallback to window.onload, that will always work
			window.attachEvent( "onload", jQuery.ready );

			// If IE and not a frame
			// continually check to see if the document is ready
			var top = false;

			try {
				top = window.frameElement == null && document.documentElement;
			} catch(e) {}

			if ( top && top.doScroll ) {
				(function doScrollCheck() {
					if ( !jQuery.isReady ) {

						try {
							// Use the trick by Diego Perini
							// http://javascript.nwbox.com/IEContentLoaded/
							top.doScroll("left");
						} catch(e) {
							return setTimeout( doScrollCheck, 50 );
						}

						// and execute any waiting functions
						jQuery.ready();
					}
				})();
			}
		}
	}
	return readyList.promise( obj );
};

// Populate the class2type map
jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
	class2type[ "[object " + name + "]" ] = name.toLowerCase();
});

function isArraylike( obj ) {
	var length = obj.length,
		type = jQuery.type( obj );

	if ( jQuery.isWindow( obj ) ) {
		return false;
	}

	if ( obj.nodeType === 1 && length ) {
		return true;
	}

	return type === "array" || type !== "function" &&
		( length === 0 ||
		typeof length === "number" && length > 0 && ( length - 1 ) in obj );
}

// All jQuery objects should point back to these
rootjQuery = jQuery(document);
// String to Object options format cache
var optionsCache = {};

// Convert String-formatted options into Object-formatted ones and store in cache
function createOptions( options ) {
	var object = optionsCache[ options ] = {};
	jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
		object[ flag ] = true;
	});
	return object;
}

/*
 * Create a callback list using the following parameters:
 *
 *	options: an optional list of space-separated options that will change how
 *			the callback list behaves or a more traditional option object
 *
 * By default a callback list will act like an event callback list and can be
 * "fired" multiple times.
 *
 * Possible options:
 *
 *	once:			will ensure the callback list can only be fired once (like a Deferred)
 *
 *	memory:			will keep track of previous values and will call any callback added
 *					after the list has been fired right away with the latest "memorized"
 *					values (like a Deferred)
 *
 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
 *
 *	stopOnFalse:	interrupt callings when a callback returns false
 *
 */
jQuery.Callbacks = function( options ) {

	// Convert options from String-formatted to Object-formatted if needed
	// (we check in cache first)
	options = typeof options === "string" ?
		( optionsCache[ options ] || createOptions( options ) ) :
		jQuery.extend( {}, options );

	var // Last fire value (for non-forgettable lists)
		memory,
		// Flag to know if list was already fired
		fired,
		// Flag to know if list is currently firing
		firing,
		// First callback to fire (used internally by add and fireWith)
		firingStart,
		// End of the loop when firing
		firingLength,
		// Index of currently firing callback (modified by remove if needed)
		firingIndex,
		// Actual callback list
		list = [],
		// Stack of fire calls for repeatable lists
		stack = !options.once && [],
		// Fire callbacks
		fire = function( data ) {
			memory = options.memory && data;
			fired = true;
			firingIndex = firingStart || 0;
			firingStart = 0;
			firingLength = list.length;
			firing = true;
			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
					memory = false; // To prevent further calls using add
					break;
				}
			}
			firing = false;
			if ( list ) {
				if ( stack ) {
					if ( stack.length ) {
						fire( stack.shift() );
					}
				} else if ( memory ) {
					list = [];
				} else {
					self.disable();
				}
			}
		},
		// Actual Callbacks object
		self = {
			// Add a callback or a collection of callbacks to the list
			add: function() {
				if ( list ) {
					// First, we save the current length
					var start = list.length;
					(function add( args ) {
						jQuery.each( args, function( _, arg ) {
							var type = jQuery.type( arg );
							if ( type === "function" ) {
								if ( !options.unique || !self.has( arg ) ) {
									list.push( arg );
								}
							} else if ( arg && arg.length && type !== "string" ) {
								// Inspect recursively
								add( arg );
							}
						});
					})( arguments );
					// Do we need to add the callbacks to the
					// current firing batch?
					if ( firing ) {
						firingLength = list.length;
					// With memory, if we're not firing then
					// we should call right away
					} else if ( memory ) {
						firingStart = start;
						fire( memory );
					}
				}
				return this;
			},
			// Remove a callback from the list
			remove: function() {
				if ( list ) {
					jQuery.each( arguments, function( _, arg ) {
						var index;
						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
							list.splice( index, 1 );
							// Handle firing indexes
							if ( firing ) {
								if ( index <= firingLength ) {
									firingLength--;
								}
								if ( index <= firingIndex ) {
									firingIndex--;
								}
							}
						}
					});
				}
				return this;
			},
			// Control if a given callback is in the list
			has: function( fn ) {
				return jQuery.inArray( fn, list ) > -1;
			},
			// Remove all callbacks from the list
			empty: function() {
				list = [];
				return this;
			},
			// Have the list do nothing anymore
			disable: function() {
				list = stack = memory = undefined;
				return this;
			},
			// Is it disabled?
			disabled: function() {
				return !list;
			},
			// Lock the list in its current state
			lock: function() {
				stack = undefined;
				if ( !memory ) {
					self.disable();
				}
				return this;
			},
			// Is it locked?
			locked: function() {
				return !stack;
			},
			// Call all callbacks with the given context and arguments
			fireWith: function( context, args ) {
				args = args || [];
				args = [ context, args.slice ? args.slice() : args ];
				if ( list && ( !fired || stack ) ) {
					if ( firing ) {
						stack.push( args );
					} else {
						fire( args );
					}
				}
				return this;
			},
			// Call all the callbacks with the given arguments
			fire: function() {
				self.fireWith( this, arguments );
				return this;
			},
			// To know if the callbacks have already been called at least once
			fired: function() {
				return !!fired;
			}
		};

	return self;
};
jQuery.extend({

	Deferred: function( func ) {
		var tuples = [
				// action, add listener, listener list, final state
				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
				[ "notify", "progress", jQuery.Callbacks("memory") ]
			],
			state = "pending",
			promise = {
				state: function() {
					return state;
				},
				always: function() {
					deferred.done( arguments ).fail( arguments );
					return this;
				},
				then: function( /* fnDone, fnFail, fnProgress */ ) {
					var fns = arguments;
					return jQuery.Deferred(function( newDefer ) {
						jQuery.each( tuples, function( i, tuple ) {
							var action = tuple[ 0 ],
								fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
							// deferred[ done | fail | progress ] for forwarding actions to newDefer
							deferred[ tuple[1] ](function() {
								var returned = fn && fn.apply( this, arguments );
								if ( returned && jQuery.isFunction( returned.promise ) ) {
									returned.promise()
										.done( newDefer.resolve )
										.fail( newDefer.reject )
										.progress( newDefer.notify );
								} else {
									newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
								}
							});
						});
						fns = null;
					}).promise();
				},
				// Get a promise for this deferred
				// If obj is provided, the promise aspect is added to the object
				promise: function( obj ) {
					return obj != null ? jQuery.extend( obj, promise ) : promise;
				}
			},
			deferred = {};

		// Keep pipe for back-compat
		promise.pipe = promise.then;

		// Add list-specific methods
		jQuery.each( tuples, function( i, tuple ) {
			var list = tuple[ 2 ],
				stateString = tuple[ 3 ];

			// promise[ done | fail | progress ] = list.add
			promise[ tuple[1] ] = list.add;

			// Handle state
			if ( stateString ) {
				list.add(function() {
					// state = [ resolved | rejected ]
					state = stateString;

				// [ reject_list | resolve_list ].disable; progress_list.lock
				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
			}

			// deferred[ resolve | reject | notify ]
			deferred[ tuple[0] ] = function() {
				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
				return this;
			};
			deferred[ tuple[0] + "With" ] = list.fireWith;
		});

		// Make the deferred a promise
		promise.promise( deferred );

		// Call given func if any
		if ( func ) {
			func.call( deferred, deferred );
		}

		// All done!
		return deferred;
	},

	// Deferred helper
	when: function( subordinate /* , ..., subordinateN */ ) {
		var i = 0,
			resolveValues = core_slice.call( arguments ),
			length = resolveValues.length,

			// the count of uncompleted subordinates
			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,

			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),

			// Update function for both resolve and progress values
			updateFunc = function( i, contexts, values ) {
				return function( value ) {
					contexts[ i ] = this;
					values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
					if( values === progressValues ) {
						deferred.notifyWith( contexts, values );
					} else if ( !( --remaining ) ) {
						deferred.resolveWith( contexts, values );
					}
				};
			},

			progressValues, progressContexts, resolveContexts;

		// add listeners to Deferred subordinates; treat others as resolved
		if ( length > 1 ) {
			progressValues = new Array( length );
			progressContexts = new Array( length );
			resolveContexts = new Array( length );
			for ( ; i < length; i++ ) {
				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
					resolveValues[ i ].promise()
						.done( updateFunc( i, resolveContexts, resolveValues ) )
						.fail( deferred.reject )
						.progress( updateFunc( i, progressContexts, progressValues ) );
				} else {
					--remaining;
				}
			}
		}

		// if we're not waiting on anything, resolve the master
		if ( !remaining ) {
			deferred.resolveWith( resolveContexts, resolveValues );
		}

		return deferred.promise();
	}
});
jQuery.support = (function() {

	var support, all, a, select, opt, input, fragment, eventName, isSupported, i,
		div = document.createElement("div");

	// Setup
	div.setAttribute( "className", "t" );
	div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";

	// Support tests won't run in some limited or non-browser environments
	all = div.getElementsByTagName("*");
	a = div.getElementsByTagName("a")[ 0 ];
	if ( !all || !a || !all.length ) {
		return {};
	}

	// First batch of tests
	select = document.createElement("select");
	opt = select.appendChild( document.createElement("option") );
	input = div.getElementsByTagName("input")[ 0 ];

	a.style.cssText = "top:1px;float:left;opacity:.5";
	support = {
		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
		getSetAttribute: div.className !== "t",

		// IE strips leading whitespace when .innerHTML is used
		leadingWhitespace: div.firstChild.nodeType === 3,

		// Make sure that tbody elements aren't automatically inserted
		// IE will insert them into empty tables
		tbody: !div.getElementsByTagName("tbody").length,

		// Make sure that link elements get serialized correctly by innerHTML
		// This requires a wrapper element in IE
		htmlSerialize: !!div.getElementsByTagName("link").length,

		// Get the style information from getAttribute
		// (IE uses .cssText instead)
		style: /top/.test( a.getAttribute("style") ),

		// Make sure that URLs aren't manipulated
		// (IE normalizes it by default)
		hrefNormalized: a.getAttribute("href") === "/a",

		// Make sure that element opacity exists
		// (IE uses filter instead)
		// Use a regex to work around a WebKit issue. See #5145
		opacity: /^0.5/.test( a.style.opacity ),

		// Verify style float existence
		// (IE uses styleFloat instead of cssFloat)
		cssFloat: !!a.style.cssFloat,

		// Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
		checkOn: !!input.value,

		// Make sure that a selected-by-default option has a working selected property.
		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
		optSelected: opt.selected,

		// Tests for enctype support on a form (#6743)
		enctype: !!document.createElement("form").enctype,

		// Makes sure cloning an html5 element does not cause problems
		// Where outerHTML is undefined, this still works
		html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",

		// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
		boxModel: document.compatMode === "CSS1Compat",

		// Will be defined later
		deleteExpando: true,
		noCloneEvent: true,
		inlineBlockNeedsLayout: false,
		shrinkWrapBlocks: false,
		reliableMarginRight: true,
		boxSizingReliable: true,
		pixelPosition: false
	};

	// Make sure checked status is properly cloned
	input.checked = true;
	support.noCloneChecked = input.cloneNode( true ).checked;

	// Make sure that the options inside disabled selects aren't marked as disabled
	// (WebKit marks them as disabled)
	select.disabled = true;
	support.optDisabled = !opt.disabled;

	// Support: IE<9
	try {
		delete div.test;
	} catch( e ) {
		support.deleteExpando = false;
	}

	// Check if we can trust getAttribute("value")
	input = document.createElement("input");
	input.setAttribute( "value", "" );
	support.input = input.getAttribute( "value" ) === "";

	// Check if an input maintains its value after becoming a radio
	input.value = "t";
	input.setAttribute( "type", "radio" );
	support.radioValue = input.value === "t";

	// #11217 - WebKit loses check when the name is after the checked attribute
	input.setAttribute( "checked", "t" );
	input.setAttribute( "name", "t" );

	fragment = document.createDocumentFragment();
	fragment.appendChild( input );

	// Check if a disconnected checkbox will retain its checked
	// value of true after appended to the DOM (IE6/7)
	support.appendChecked = input.checked;

	// WebKit doesn't clone checked state correctly in fragments
	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;

	// Support: IE<9
	// Opera does not clone events (and typeof div.attachEvent === undefined).
	// IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
	if ( div.attachEvent ) {
		div.attachEvent( "onclick", function() {
			support.noCloneEvent = false;
		});

		div.cloneNode( true ).click();
	}

	// Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
	// Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php
	for ( i in { submit: true, change: true, focusin: true }) {
		div.setAttribute( eventName = "on" + i, "t" );

		support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false;
	}

	div.style.backgroundClip = "content-box";
	div.cloneNode( true ).style.backgroundClip = "";
	support.clearCloneStyle = div.style.backgroundClip === "content-box";

	// Run tests that need a body at doc ready
	jQuery(function() {
		var container, marginDiv, tds,
			divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
			body = document.getElementsByTagName("body")[0];

		if ( !body ) {
			// Return for frameset docs that don't have a body
			return;
		}

		container = document.createElement("div");
		container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";

		body.appendChild( container ).appendChild( div );

		// Support: IE8
		// Check if table cells still have offsetWidth/Height when they are set
		// to display:none and there are still other visible table cells in a
		// table row; if so, offsetWidth/Height are not reliable for use when
		// determining if an element has been hidden directly using
		// display:none (it is still safe to use offsets if a parent element is
		// hidden; don safety goggles and see bug #4512 for more information).
		div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
		tds = div.getElementsByTagName("td");
		tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
		isSupported = ( tds[ 0 ].offsetHeight === 0 );

		tds[ 0 ].style.display = "";
		tds[ 1 ].style.display = "none";

		// Support: IE8
		// Check if empty table cells still have offsetWidth/Height
		support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );

		// Check box-sizing and margin behavior
		div.innerHTML = "";
		div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
		support.boxSizing = ( div.offsetWidth === 4 );
		support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );

		// Use window.getComputedStyle because jsdom on node.js will break without it.
		if ( window.getComputedStyle ) {
			support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
			support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";

			// Check if div with explicit width and no margin-right incorrectly
			// gets computed margin-right based on width of container. (#3333)
			// Fails in WebKit before Feb 2011 nightlies
			// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
			marginDiv = div.appendChild( document.createElement("div") );
			marginDiv.style.cssText = div.style.cssText = divReset;
			marginDiv.style.marginRight = marginDiv.style.width = "0";
			div.style.width = "1px";

			support.reliableMarginRight =
				!parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
		}

		if ( typeof div.style.zoom !== "undefined" ) {
			// Support: IE<8
			// Check if natively block-level elements act like inline-block
			// elements when setting their display to 'inline' and giving
			// them layout
			div.innerHTML = "";
			div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
			support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );

			// Support: IE6
			// Check if elements with layout shrink-wrap their children
			div.style.display = "block";
			div.innerHTML = "<div></div>";
			div.firstChild.style.width = "5px";
			support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );

			// Prevent IE 6 from affecting layout for positioned elements #11048
			// Prevent IE from shrinking the body in IE 7 mode #12869
			body.style.zoom = 1;
		}

		body.removeChild( container );

		// Null elements to avoid leaks in IE
		container = div = tds = marginDiv = null;
	});

	// Null elements to avoid leaks in IE
	all = select = fragment = opt = a = input = null;

	return support;
})();

var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
	rmultiDash = /([A-Z])/g;
	
function internalData( elem, name, data, pvt /* Internal Use Only */ ){
	if ( !jQuery.acceptData( elem ) ) {
		return;
	}

	var thisCache, ret,
		internalKey = jQuery.expando,
		getByName = typeof name === "string",

		// We have to handle DOM nodes and JS objects differently because IE6-7
		// can't GC object references properly across the DOM-JS boundary
		isNode = elem.nodeType,

		// Only DOM nodes need the global jQuery cache; JS object data is
		// attached directly to the object so GC can occur automatically
		cache = isNode ? jQuery.cache : elem,

		// Only defining an ID for JS objects if its cache already exists allows
		// the code to shortcut on the same path as a DOM node with no cache
		id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;

	// Avoid doing any more work than we need to when trying to get data on an
	// object that has no data at all
	if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
		return;
	}

	if ( !id ) {
		// Only DOM nodes need a new unique ID for each element since their data
		// ends up in the global cache
		if ( isNode ) {
			elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++;
		} else {
			id = internalKey;
		}
	}

	if ( !cache[ id ] ) {
		cache[ id ] = {};

		// Avoids exposing jQuery metadata on plain JS objects when the object
		// is serialized using JSON.stringify
		if ( !isNode ) {
			cache[ id ].toJSON = jQuery.noop;
		}
	}

	// An object can be passed to jQuery.data instead of a key/value pair; this gets
	// shallow copied over onto the existing cache
	if ( typeof name === "object" || typeof name === "function" ) {
		if ( pvt ) {
			cache[ id ] = jQuery.extend( cache[ id ], name );
		} else {
			cache[ id ].data = jQuery.extend( cache[ id ].data, name );
		}
	}

	thisCache = cache[ id ];

	// jQuery data() is stored in a separate object inside the object's internal data
	// cache in order to avoid key collisions between internal data and user-defined
	// data.
	if ( !pvt ) {
		if ( !thisCache.data ) {
			thisCache.data = {};
		}

		thisCache = thisCache.data;
	}

	if ( data !== undefined ) {
		thisCache[ jQuery.camelCase( name ) ] = data;
	}

	// Check for both converted-to-camel and non-converted data property names
	// If a data property was specified
	if ( getByName ) {

		// First Try to find as-is property data
		ret = thisCache[ name ];

		// Test for null|undefined property data
		if ( ret == null ) {

			// Try to find the camelCased property
			ret = thisCache[ jQuery.camelCase( name ) ];
		}
	} else {
		ret = thisCache;
	}

	return ret;
}

function internalRemoveData( elem, name, pvt /* For internal use only */ ){
	if ( !jQuery.acceptData( elem ) ) {
		return;
	}

	var thisCache, i, l,

		isNode = elem.nodeType,

		// See jQuery.data for more information
		cache = isNode ? jQuery.cache : elem,
		id = isNode ? elem[ jQuery.expando ] : jQuery.expando;

	// If there is already no cache entry for this object, there is no
	// purpose in continuing
	if ( !cache[ id ] ) {
		return;
	}

	if ( name ) {

		thisCache = pvt ? cache[ id ] : cache[ id ].data;

		if ( thisCache ) {

			// Support array or space separated string names for data keys
			if ( !jQuery.isArray( name ) ) {

				// try the string as a key before any manipulation
				if ( name in thisCache ) {
					name = [ name ];
				} else {

					// split the camel cased version by spaces unless a key with the spaces exists
					name = jQuery.camelCase( name );
					if ( name in thisCache ) {
						name = [ name ];
					} else {
						name = name.split(" ");
					}
				}
			} else {
				// If "name" is an array of keys...
				// When data is initially created, via ("key", "val") signature,
				// keys will be converted to camelCase.
				// Since there is no way to tell _how_ a key was added, remove
				// both plain key and camelCase key. #12786
				// This will only penalize the array argument path.
				name = name.concat( jQuery.map( name, jQuery.camelCase ) );
			}

			for ( i = 0, l = name.length; i < l; i++ ) {
				delete thisCache[ name[i] ];
			}

			// If there is no data left in the cache, we want to continue
			// and let the cache object itself get destroyed
			if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
				return;
			}
		}
	}

	// See jQuery.data for more information
	if ( !pvt ) {
		delete cache[ id ].data;

		// Don't destroy the parent cache unless the internal data object
		// had been the only thing left in it
		if ( !isEmptyDataObject( cache[ id ] ) ) {
			return;
		}
	}

	// Destroy the cache
	if ( isNode ) {
		jQuery.cleanData( [ elem ], true );

	// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
	} else if ( jQuery.support.deleteExpando || cache != cache.window ) {
		delete cache[ id ];

	// When all else fails, null
	} else {
		cache[ id ] = null;
	}
}

jQuery.extend({
	cache: {},

	// Unique for each copy of jQuery on the page
	// Non-digits removed to match rinlinejQuery
	expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),

	// The following elements throw uncatchable exceptions if you
	// attempt to add expando properties to them.
	noData: {
		"embed": true,
		// Ban all objects except for Flash (which handle expandos)
		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
		"applet": true
	},

	hasData: function( elem ) {
		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
		return !!elem && !isEmptyDataObject( elem );
	},

	data: function( elem, name, data ) {
		return internalData( elem, name, data, false );
	},

	removeData: function( elem, name ) {
		return internalRemoveData( elem, name, false );
	},

	// For internal use only.
	_data: function( elem, name, data ) {
		return internalData( elem, name, data, true );
	},
	
	_removeData: function( elem, name ) {
		return internalRemoveData( elem, name, true );
	},

	// A method for determining if a DOM node can handle the data expando
	acceptData: function( elem ) {
		var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];

		// nodes accept data unless otherwise specified; rejection can be conditional
		return !noData || noData !== true && elem.getAttribute("classid") === noData;
	}
});

jQuery.fn.extend({
	data: function( key, value ) {
		var attrs, name,
			elem = this[0],
			i = 0,
			data = null;

		// Gets all values
		if ( key === undefined ) {
			if ( this.length ) {
				data = jQuery.data( elem );

				if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
					attrs = elem.attributes;
					for ( ; i < attrs.length; i++ ) {
						name = attrs[i].name;

						if ( !name.indexOf( "data-" ) ) {
							name = jQuery.camelCase( name.substring(5) );

							dataAttr( elem, name, data[ name ] );
						}
					}
					jQuery._data( elem, "parsedAttrs", true );
				}
			}

			return data;
		}

		// Sets multiple values
		if ( typeof key === "object" ) {
			return this.each(function() {
				jQuery.data( this, key );
			});
		}

		return jQuery.access( this, function( value ) {

			if ( value === undefined ) {
				// Try to fetch any internally stored data first
				return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null;
			}

			this.each(function() {
				jQuery.data( this, key, value );
			});
		}, null, value, arguments.length > 1, null, true );
	},

	removeData: function( key ) {
		return this.each(function() {
			jQuery.removeData( this, key );
		});
	}
});

function dataAttr( elem, key, data ) {
	// If nothing was found internally, try to fetch any
	// data from the HTML5 data-* attribute
	if ( data === undefined && elem.nodeType === 1 ) {

		var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();

		data = elem.getAttribute( name );

		if ( typeof data === "string" ) {
			try {
				data = data === "true" ? true :
				data === "false" ? false :
				data === "null" ? null :
				// Only convert to a number if it doesn't change the string
				+data + "" === data ? +data :
				rbrace.test( data ) ? jQuery.parseJSON( data ) :
					data;
			} catch( e ) {}

			// Make sure we set the data so it isn't changed later
			jQuery.data( elem, key, data );

		} else {
			data = undefined;
		}
	}

	return data;
}

// checks a cache object for emptiness
function isEmptyDataObject( obj ) {
	var name;
	for ( name in obj ) {

		// if the public data object is empty, the private is still empty
		if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
			continue;
		}
		if ( name !== "toJSON" ) {
			return false;
		}
	}

	return true;
}
jQuery.extend({
	queue: function( elem, type, data ) {
		var queue;

		if ( elem ) {
			type = ( type || "fx" ) + "queue";
			queue = jQuery._data( elem, type );

			// Speed up dequeue by getting out quickly if this is just a lookup
			if ( data ) {
				if ( !queue || jQuery.isArray(data) ) {
					queue = jQuery._data( elem, type, jQuery.makeArray(data) );
				} else {
					queue.push( data );
				}
			}
			return queue || [];
		}
	},

	dequeue: function( elem, type ) {
		type = type || "fx";

		var queue = jQuery.queue( elem, type ),
			startLength = queue.length,
			fn = queue.shift(),
			hooks = jQuery._queueHooks( elem, type ),
			next = function() {
				jQuery.dequeue( elem, type );
			};

		// If the fx queue is dequeued, always remove the progress sentinel
		if ( fn === "inprogress" ) {
			fn = queue.shift();
			startLength--;
		}

		hooks.cur = fn;
		if ( fn ) {

			// Add a progress sentinel to prevent the fx queue from being
			// automatically dequeued
			if ( type === "fx" ) {
				queue.unshift( "inprogress" );
			}

			// clear up the last queue stop function
			delete hooks.stop;
			fn.call( elem, next, hooks );
		}

		if ( !startLength && hooks ) {
			hooks.empty.fire();
		}
	},

	// not intended for public consumption - generates a queueHooks object, or returns the current one
	_queueHooks: function( elem, type ) {
		var key = type + "queueHooks";
		return jQuery._data( elem, key ) || jQuery._data( elem, key, {
			empty: jQuery.Callbacks("once memory").add(function() {
				jQuery._removeData( elem, type + "queue" );
				jQuery._removeData( elem, key );
			})
		});
	}
});

jQuery.fn.extend({
	queue: function( type, data ) {
		var setter = 2;

		if ( typeof type !== "string" ) {
			data = type;
			type = "fx";
			setter--;
		}

		if ( arguments.length < setter ) {
			return jQuery.queue( this[0], type );
		}

		return data === undefined ?
			this :
			this.each(function() {
				var queue = jQuery.queue( this, type, data );

				// ensure a hooks for this queue
				jQuery._queueHooks( this, type );

				if ( type === "fx" && queue[0] !== "inprogress" ) {
					jQuery.dequeue( this, type );
				}
			});
	},
	dequeue: function( type ) {
		return this.each(function() {
			jQuery.dequeue( this, type );
		});
	},
	// Based off of the plugin by Clint Helfers, with permission.
	// http://blindsignals.com/index.php/2009/07/jquery-delay/
	delay: function( time, type ) {
		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
		type = type || "fx";

		return this.queue( type, function( next, hooks ) {
			var timeout = setTimeout( next, time );
			hooks.stop = function() {
				clearTimeout( timeout );
			};
		});
	},
	clearQueue: function( type ) {
		return this.queue( type || "fx", [] );
	},
	// Get a promise resolved when queues of a certain type
	// are emptied (fx is the type by default)
	promise: function( type, obj ) {
		var tmp,
			count = 1,
			defer = jQuery.Deferred(),
			elements = this,
			i = this.length,
			resolve = function() {
				if ( !( --count ) ) {
					defer.resolveWith( elements, [ elements ] );
				}
			};

		if ( typeof type !== "string" ) {
			obj = type;
			type = undefined;
		}
		type = type || "fx";

		while( i-- ) {
			tmp = jQuery._data( elements[ i ], type + "queueHooks" );
			if ( tmp && tmp.empty ) {
				count++;
				tmp.empty.add( resolve );
			}
		}
		resolve();
		return defer.promise( obj );
	}
});
var nodeHook, boolHook,
	rclass = /[\t\r\n]/g,
	rreturn = /\r/g,
	rfocusable = /^(?:input|select|textarea|button|object)$/i,
	rclickable = /^(?:a|area)$/i,
	rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i,
	ruseDefault = /^(?:checked|selected)$/i,
	getSetAttribute = jQuery.support.getSetAttribute,
	getSetInput = jQuery.support.input;

jQuery.fn.extend({
	attr: function( name, value ) {
		return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
	},

	removeAttr: function( name ) {
		return this.each(function() {
			jQuery.removeAttr( this, name );
		});
	},

	prop: function( name, value ) {
		return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
	},

	removeProp: function( name ) {
		name = jQuery.propFix[ name ] || name;
		return this.each(function() {
			// try/catch handles cases where IE balks (such as removing a property on window)
			try {
				this[ name ] = undefined;
				delete this[ name ];
			} catch( e ) {}
		});
	},

	addClass: function( value ) {
		var classes, elem, cur, clazz, j,
			i = 0,
			len = this.length,
			proceed = typeof value === "string" && value;

		if ( jQuery.isFunction( value ) ) {
			return this.each(function( j ) {
				jQuery( this ).addClass( value.call( this, j, this.className ) );
			});
		}

		if ( proceed ) {
			// The disjunction here is for better compressibility (see removeClass)
			classes = ( value || "" ).match( core_rnotwhite ) || [];

			for ( ; i < len; i++ ) {
				elem = this[ i ];
				cur = elem.nodeType === 1 && ( elem.className ?
					( " " + elem.className + " " ).replace( rclass, " " ) :
					" "
				);

				if ( cur ) {
					j = 0;
					while ( (clazz = classes[j++]) ) {
						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
							cur += clazz + " ";
						}
					}
					elem.className = jQuery.trim( cur );

				}
			}
		}

		return this;
	},

	removeClass: function( value ) {
		var classes, elem, cur, clazz, j,
			i = 0,
			len = this.length,
			proceed = arguments.length === 0 || typeof value === "string" && value;

		if ( jQuery.isFunction( value ) ) {
			return this.each(function( j ) {
				jQuery( this ).removeClass( value.call( this, j, this.className ) );
			});
		}
		if ( proceed ) {
			classes = ( value || "" ).match( core_rnotwhite ) || [];

			for ( ; i < len; i++ ) {
				elem = this[ i ];
				// This expression is here for better compressibility (see addClass)
				cur = elem.nodeType === 1 && ( elem.className ?
					( " " + elem.className + " " ).replace( rclass, " " ) :
					""
				);

				if ( cur ) {
					j = 0;
					while ( (clazz = classes[j++]) ) {
						// Remove *all* instances
						while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
							cur = cur.replace( " " + clazz + " ", " " );
						}
					}
					elem.className = value ? jQuery.trim( cur ) : "";
				}
			}
		}

		return this;
	},

	toggleClass: function( value, stateVal ) {
		var type = typeof value,
			isBool = typeof stateVal === "boolean";

		if ( jQuery.isFunction( value ) ) {
			return this.each(function( i ) {
				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
			});
		}

		return this.each(function() {
			if ( type === "string" ) {
				// toggle individual class names
				var className,
					i = 0,
					self = jQuery( this ),
					state = stateVal,
					classNames = value.match( core_rnotwhite ) || [];

				while ( (className = classNames[ i++ ]) ) {
					// check each className given, space separated list
					state = isBool ? state : !self.hasClass( className );
					self[ state ? "addClass" : "removeClass" ]( className );
				}

			// Toggle whole class name
			} else if ( type === "undefined" || type === "boolean" ) {
				if ( this.className ) {
					// store className if set
					jQuery._data( this, "__className__", this.className );
				}

				// If the element has a class name or if we're passed "false",
				// then remove the whole classname (if there was one, the above saved it).
				// Otherwise bring back whatever was previously saved (if anything),
				// falling back to the empty string if nothing was stored.
				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
			}
		});
	},

	hasClass: function( selector ) {
		var className = " " + selector + " ",
			i = 0,
			l = this.length;
		for ( ; i < l; i++ ) {
			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
				return true;
			}
		}

		return false;
	},

	val: function( value ) {
		var hooks, ret, isFunction,
			elem = this[0];

		if ( !arguments.length ) {
			if ( elem ) {
				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];

				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
					return ret;
				}

				ret = elem.value;

				return typeof ret === "string" ?
					// handle most common string cases
					ret.replace(rreturn, "") :
					// handle cases where value is null/undef or number
					ret == null ? "" : ret;
			}

			return;
		}

		isFunction = jQuery.isFunction( value );

		return this.each(function( i ) {
			var val,
				self = jQuery(this);

			if ( this.nodeType !== 1 ) {
				return;
			}

			if ( isFunction ) {
				val = value.call( this, i, self.val() );
			} else {
				val = value;
			}

			// Treat null/undefined as ""; convert numbers to string
			if ( val == null ) {
				val = "";
			} else if ( typeof val === "number" ) {
				val += "";
			} else if ( jQuery.isArray( val ) ) {
				val = jQuery.map(val, function ( value ) {
					return value == null ? "" : value + "";
				});
			}

			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];

			// If set returns undefined, fall back to normal setting
			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
				this.value = val;
			}
		});
	}
});

jQuery.extend({
	valHooks: {
		option: {
			get: function( elem ) {
				// attributes.value is undefined in Blackberry 4.7 but
				// uses .value. See #6932
				var val = elem.attributes.value;
				return !val || val.specified ? elem.value : elem.text;
			}
		},
		select: {
			get: function( elem ) {
				var value, option,
					options = elem.options,
					index = elem.selectedIndex,
					one = elem.type === "select-one" || index < 0,
					values = one ? null : [],
					max = one ? index + 1 : options.length,
					i = index < 0 ?
						max :
						one ? index : 0;

				// Loop through all the selected options
				for ( ; i < max; i++ ) {
					option = options[ i ];

					// oldIE doesn't update selected after form reset (#2551)
					if ( ( option.selected || i === index ) &&
							// Don't return options that are disabled or in a disabled optgroup
							( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
							( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {

						// Get the specific value for the option
						value = jQuery( option ).val();

						// We don't need an array for one selects
						if ( one ) {
							return value;
						}

						// Multi-Selects return an array
						values.push( value );
					}
				}

				return values;
			},

			set: function( elem, value ) {
				var values = jQuery.makeArray( value );

				jQuery(elem).find("option").each(function() {
					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
				});

				if ( !values.length ) {
					elem.selectedIndex = -1;
				}
				return values;
			}
		}
	},

	attr: function( elem, name, value ) {
		var ret, hooks, notxml,
			nType = elem.nodeType;

		// don't get/set attributes on text, comment and attribute nodes
		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
			return;
		}

		// Fallback to prop when attributes are not supported
		if ( typeof elem.getAttribute === "undefined" ) {
			return jQuery.prop( elem, name, value );
		}

		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );

		// All attributes are lowercase
		// Grab necessary hook if one is defined
		if ( notxml ) {
			name = name.toLowerCase();
			hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
		}

		if ( value !== undefined ) {

			if ( value === null ) {
				jQuery.removeAttr( elem, name );

			} else if ( hooks && notxml && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
				return ret;

			} else {
				elem.setAttribute( name, value + "" );
				return value;
			}

		} else if ( hooks && notxml && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
			return ret;

		} else {

			// In IE9+, Flash objects don't have .getAttribute (#12945)
			// Support: IE9+
			if ( typeof elem.getAttribute !== "undefined" ) {
				ret =  elem.getAttribute( name );
			}

			// Non-existent attributes return null, we normalize to undefined
			return ret == null ?
				undefined :
				ret;
		}
	},

	removeAttr: function( elem, value ) {
		var name, propName,
			i = 0,
			attrNames = value && value.match( core_rnotwhite );

		if ( attrNames && elem.nodeType === 1 ) {
			while ( (name = attrNames[i++]) ) {
				propName = jQuery.propFix[ name ] || name;

				// Boolean attributes get special treatment (#10870)
				if ( rboolean.test( name ) ) {
					// Set corresponding property to false for boolean attributes
					// Also clear defaultChecked/defaultSelected (if appropriate) for IE<8
					if ( !getSetAttribute && ruseDefault.test( name ) ) {
						elem[ jQuery.camelCase( "default-" + name ) ] =
							elem[ propName ] = false;
					} else {
						elem[ propName ] = false;
					}

				// See #9699 for explanation of this approach (setting first, then removal)
				} else {
					jQuery.attr( elem, name, "" );
				}

				elem.removeAttribute( getSetAttribute ? name : propName );
			}
		}
	},

	attrHooks: {
		type: {
			set: function( elem, value ) {
				if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
					// Setting the type on a radio button after the value resets the value in IE6-9
					// Reset value to default in case type is set after value during creation
					var val = elem.value;
					elem.setAttribute( "type", value );
					if ( val ) {
						elem.value = val;
					}
					return value;
				}
			}
		}
	},

	propFix: {
		tabindex: "tabIndex",
		readonly: "readOnly",
		"for": "htmlFor",
		"class": "className",
		maxlength: "maxLength",
		cellspacing: "cellSpacing",
		cellpadding: "cellPadding",
		rowspan: "rowSpan",
		colspan: "colSpan",
		usemap: "useMap",
		frameborder: "frameBorder",
		contenteditable: "contentEditable"
	},

	prop: function( elem, name, value ) {
		var ret, hooks, notxml,
			nType = elem.nodeType;

		// don't get/set properties on text, comment and attribute nodes
		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
			return;
		}

		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );

		if ( notxml ) {
			// Fix name and attach hooks
			name = jQuery.propFix[ name ] || name;
			hooks = jQuery.propHooks[ name ];
		}

		if ( value !== undefined ) {
			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
				return ret;

			} else {
				return ( elem[ name ] = value );
			}

		} else {
			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
				return ret;

			} else {
				return elem[ name ];
			}
		}
	},

	propHooks: {
		tabIndex: {
			get: function( elem ) {
				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
				var attributeNode = elem.getAttributeNode("tabindex");

				return attributeNode && attributeNode.specified ?
					parseInt( attributeNode.value, 10 ) :
					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
						0 :
						undefined;
			}
		}
	}
});

// Hook for boolean attributes
boolHook = {
	get: function( elem, name ) {
		var
			// Use .prop to determine if this attribute is understood as boolean
			prop = jQuery.prop( elem, name ),

			// Fetch it accordingly
			attr = typeof prop === "boolean" && elem.getAttribute( name ),
			detail = typeof prop === "boolean" ?

				getSetInput && getSetAttribute ?
					attr != null :
					// oldIE fabricates an empty string for missing boolean attributes
					// and conflates checked/selected into attroperties
					ruseDefault.test( name ) ?
						elem[ jQuery.camelCase( "default-" + name ) ] :
						!!attr :

				// fetch an attribute node for properties not recognized as boolean
				elem.getAttributeNode( name );

		return detail && detail.value !== false ?
			name.toLowerCase() :
			undefined;
	},
	set: function( elem, value, name ) {
		if ( value === false ) {
			// Remove boolean attributes when set to false
			jQuery.removeAttr( elem, name );
		} else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
			// IE<8 needs the *property* name
			elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );

		// Use defaultChecked and defaultSelected for oldIE
		} else {
			elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true;
		}

		return name;
	}
};

// fix oldIE value attroperty
if ( !getSetInput || !getSetAttribute ) {
	jQuery.attrHooks.value = {
		get: function( elem, name ) {
			var ret = elem.getAttributeNode( name );
			return jQuery.nodeName( elem, "input" ) ?

				// Ignore the value *property* by using defaultValue
				elem.defaultValue :

				ret && ret.specified ? ret.value : undefined;
		},
		set: function( elem, value, name ) {
			if ( jQuery.nodeName( elem, "input" ) ) {
				// Does not return so that setAttribute is also used
				elem.defaultValue = value;
			} else {
				// Use nodeHook if defined (#1954); otherwise setAttribute is fine
				return nodeHook && nodeHook.set( elem, value, name );
			}
		}
	};
}

// IE6/7 do not support getting/setting some attributes with get/setAttribute
if ( !getSetAttribute ) {

	// Use this for any attribute in IE6/7
	// This fixes almost every IE6/7 issue
	nodeHook = jQuery.valHooks.button = {
		get: function( elem, name ) {
			var ret = elem.getAttributeNode( name );
			return ret && ( name === "id" || name === "name" || name === "coords" ? ret.value !== "" : ret.specified ) ?
				ret.value :
				undefined;
		},
		set: function( elem, value, name ) {
			// Set the existing or create a new attribute node
			var ret = elem.getAttributeNode( name );
			if ( !ret ) {
				elem.setAttributeNode(
					(ret = elem.ownerDocument.createAttribute( name ))
				);
			}

			ret.value = value += "";

			// Break association with cloned elements by also using setAttribute (#9646)
			return name === "value" || value === elem.getAttribute( name ) ?
				value :
				undefined;
		}
	};

	// Set contenteditable to false on removals(#10429)
	// Setting to empty string throws an error as an invalid value
	jQuery.attrHooks.contenteditable = {
		get: nodeHook.get,
		set: function( elem, value, name ) {
			nodeHook.set( elem, value === "" ? false : value, name );
		}
	};

	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
	// This is for removals
	jQuery.each([ "width", "height" ], function( i, name ) {
		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
			set: function( elem, value ) {
				if ( value === "" ) {
					elem.setAttribute( name, "auto" );
					return value;
				}
			}
		});
	});
}


// Some attributes require a special call on IE
// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
if ( !jQuery.support.hrefNormalized ) {
	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
			get: function( elem ) {
				var ret = elem.getAttribute( name, 2 );
				return ret == null ? undefined : ret;
			}
		});
	});

	// href/src property should get the full normalized URL (#10299/#12915)
	jQuery.each([ "href", "src" ], function( i, name ) {
		jQuery.propHooks[ name ] = {
			get: function( elem ) {
				return elem.getAttribute( name, 4 );
			}
		};
	});
}

if ( !jQuery.support.style ) {
	jQuery.attrHooks.style = {
		get: function( elem ) {
			// Return undefined in the case of empty string
			// Note: IE uppercases css property names, but if we were to .toLowerCase()
			// .cssText, that would destroy case senstitivity in URL's, like in "background"
			return elem.style.cssText || undefined;
		},
		set: function( elem, value ) {
			return ( elem.style.cssText = value + "" );
		}
	};
}

// Safari mis-reports the default selected property of an option
// Accessing the parent's selectedIndex property fixes it
if ( !jQuery.support.optSelected ) {
	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
		get: function( elem ) {
			var parent = elem.parentNode;

			if ( parent ) {
				parent.selectedIndex;

				// Make sure that it also works with optgroups, see #5701
				if ( parent.parentNode ) {
					parent.parentNode.selectedIndex;
				}
			}
			return null;
		}
	});
}

// IE6/7 call enctype encoding
if ( !jQuery.support.enctype ) {
	jQuery.propFix.enctype = "encoding";
}

// Radios and checkboxes getter/setter
if ( !jQuery.support.checkOn ) {
	jQuery.each([ "radio", "checkbox" ], function() {
		jQuery.valHooks[ this ] = {
			get: function( elem ) {
				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
				return elem.getAttribute("value") === null ? "on" : elem.value;
			}
		};
	});
}
jQuery.each([ "radio", "checkbox" ], function() {
	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
		set: function( elem, value ) {
			if ( jQuery.isArray( value ) ) {
				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
			}
		}
	});
});
var rformElems = /^(?:input|select|textarea)$/i,
	rkeyEvent = /^key/,
	rmouseEvent = /^(?:mouse|contextmenu)|click/,
	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
	rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;

function returnTrue() {
	return true;
}

function returnFalse() {
	return false;
}

/*
 * Helper functions for managing events -- not part of the public interface.
 * Props to Dean Edwards' addEvent library for many of the ideas.
 */
jQuery.event = {

	global: {},

	add: function( elem, types, handler, data, selector ) {

		var handleObjIn, eventHandle, tmp,
			events, t, handleObj,
			special, handlers, type, namespaces, origType,
			// Don't attach events to noData or text/comment nodes (but allow plain objects)
			elemData = elem.nodeType !== 3 && elem.nodeType !== 8 && jQuery._data( elem );

		if ( !elemData ) {
			return;
		}

		// Caller can pass in an object of custom data in lieu of the handler
		if ( handler.handler ) {
			handleObjIn = handler;
			handler = handleObjIn.handler;
			selector = handleObjIn.selector;
		}

		// Make sure that the handler has a unique ID, used to find/remove it later
		if ( !handler.guid ) {
			handler.guid = jQuery.guid++;
		}

		// Init the element's event structure and main handler, if this is the first
		if ( !(events = elemData.events) ) {
			events = elemData.events = {};
		}
		if ( !(eventHandle = elemData.handle) ) {
			eventHandle = elemData.handle = function( e ) {
				// Discard the second event of a jQuery.event.trigger() and
				// when an event is called after a page has unloaded
				return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
					jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
					undefined;
			};
			// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
			eventHandle.elem = elem;
		}

		// Handle multiple events separated by a space
		// jQuery(...).bind("mouseover mouseout", fn);
		types = ( types || "" ).match( core_rnotwhite ) || [""];
		t = types.length;
		while ( t-- ) {
			tmp = rtypenamespace.exec( types[t] ) || [];
			type = origType = tmp[1];
			namespaces = ( tmp[2] || "" ).split( "." ).sort();

			// If event changes its type, use the special event handlers for the changed type
			special = jQuery.event.special[ type ] || {};

			// If selector defined, determine special event api type, otherwise given type
			type = ( selector ? special.delegateType : special.bindType ) || type;

			// Update special based on newly reset type
			special = jQuery.event.special[ type ] || {};

			// handleObj is passed to all event handlers
			handleObj = jQuery.extend({
				type: type,
				origType: origType,
				data: data,
				handler: handler,
				guid: handler.guid,
				selector: selector,
				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
				namespace: namespaces.join(".")
			}, handleObjIn );

			// Init the event handler queue if we're the first
			if ( !(handlers = events[ type ]) ) {
				handlers = events[ type ] = [];
				handlers.delegateCount = 0;

				// Only use addEventListener/attachEvent if the special events handler returns false
				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
					// Bind the global event handler to the element
					if ( elem.addEventListener ) {
						elem.addEventListener( type, eventHandle, false );

					} else if ( elem.attachEvent ) {
						elem.attachEvent( "on" + type, eventHandle );
					}
				}
			}

			if ( special.add ) {
				special.add.call( elem, handleObj );

				if ( !handleObj.handler.guid ) {
					handleObj.handler.guid = handler.guid;
				}
			}

			// Add to the element's handler list, delegates in front
			if ( selector ) {
				handlers.splice( handlers.delegateCount++, 0, handleObj );
			} else {
				handlers.push( handleObj );
			}

			// Keep track of which events have ever been used, for event optimization
			jQuery.event.global[ type ] = true;
		}

		// Nullify elem to prevent memory leaks in IE
		elem = null;
	},

	// Detach an event or set of events from an element
	remove: function( elem, types, handler, selector, mappedTypes ) {

		var j, origCount, tmp,
			events, t, handleObj,
			special, handlers, type, namespaces, origType,
			elemData = jQuery.hasData( elem ) && jQuery._data( elem );

		if ( !elemData || !(events = elemData.events) ) {
			return;
		}

		// Once for each type.namespace in types; type may be omitted
		types = ( types || "" ).match( core_rnotwhite ) || [""];
		t = types.length;
		while ( t-- ) {
			tmp = rtypenamespace.exec( types[t] ) || [];
			type = origType = tmp[1];
			namespaces = ( tmp[2] || "" ).split( "." ).sort();

			// Unbind all events (on this namespace, if provided) for the element
			if ( !type ) {
				for ( type in events ) {
					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
				}
				continue;
			}

			special = jQuery.event.special[ type ] || {};
			type = ( selector ? special.delegateType : special.bindType ) || type;
			handlers = events[ type ] || [];
			tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" );

			// Remove matching events
			origCount = j = handlers.length;
			while ( j-- ) {
				handleObj = handlers[ j ];

				if ( ( mappedTypes || origType === handleObj.origType ) &&
					( !handler || handler.guid === handleObj.guid ) &&
					( !tmp || tmp.test( handleObj.namespace ) ) &&
					( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
					handlers.splice( j, 1 );

					if ( handleObj.selector ) {
						handlers.delegateCount--;
					}
					if ( special.remove ) {
						special.remove.call( elem, handleObj );
					}
				}
			}

			// Remove generic event handler if we removed something and no more handlers exist
			// (avoids potential for endless recursion during removal of special event handlers)
			if ( origCount && !handlers.length ) {
				if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
					jQuery.removeEvent( elem, type, elemData.handle );
				}

				delete events[ type ];
			}
		}

		// Remove the expando if it's no longer used
		if ( jQuery.isEmptyObject( events ) ) {
			delete elemData.handle;

			// removeData also checks for emptiness and clears the expando if empty
			// so use it instead of delete
			jQuery._removeData( elem, "events" );
		}
	},

	trigger: function( event, data, elem, onlyHandlers ) {

		var i, cur, tmp, bubbleType, ontype, handle, special,
			eventPath = [ elem || document ],
			type = event.type || event,
			namespaces = event.namespace ? event.namespace.split(".") : [];

		cur = tmp = elem = elem || document;

		// Don't do events on text and comment nodes
		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
			return;
		}

		// focus/blur morphs to focusin/out; ensure we're not firing them right now
		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
			return;
		}

		if ( type.indexOf(".") >= 0 ) {
			// Namespaced trigger; create a regexp to match event type in handle()
			namespaces = type.split(".");
			type = namespaces.shift();
			namespaces.sort();
		}
		ontype = type.indexOf(":") < 0 && "on" + type;

		// Caller can pass in a jQuery.Event object, Object, or just an event type string
		event = event[ jQuery.expando ] ?
			event :
			new jQuery.Event( type, typeof event === "object" && event );

		event.isTrigger = true;
		event.namespace = namespaces.join(".");
		event.namespace_re = event.namespace ?
			new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) :
			null;

		// Clean up the event in case it is being reused
		event.result = undefined;
		if ( !event.target ) {
			event.target = elem;
		}

		// Clone any incoming data and prepend the event, creating the handler arg list
		data = data == null ?
			[ event ] :
			jQuery.makeArray( data, [ event ] );

		// Allow special events to draw outside the lines
		special = jQuery.event.special[ type ] || {};
		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
			return;
		}

		// Determine event propagation path in advance, per W3C events spec (#9951)
		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {

			bubbleType = special.delegateType || type;
			if ( !rfocusMorph.test( bubbleType + type ) ) {
				cur = cur.parentNode;
			}
			for ( ; cur; cur = cur.parentNode ) {
				eventPath.push( cur );
				tmp = cur;
			}

			// Only add window if we got to document (e.g., not plain obj or detached DOM)
			if ( tmp === (elem.ownerDocument || document) ) {
				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
			}
		}

		// Fire handlers on the event path
		i = 0;
		while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {

			event.type = i > 1 ?
				bubbleType :
				special.bindType || type;

			// jQuery handler
			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
			if ( handle ) {
				handle.apply( cur, data );
			}

			// Native handler
			handle = ontype && cur[ ontype ];
			if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
				event.preventDefault();
			}
		}
		event.type = type;

		// If nobody prevented the default action, do it now
		if ( !onlyHandlers && !event.isDefaultPrevented() ) {

			if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {

				// Call a native DOM method on the target with the same name name as the event.
				// Can't use an .isFunction() check here because IE6/7 fails that test.
				// Don't do default actions on window, that's where global variables be (#6170)
				if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) {

					// Don't re-trigger an onFOO event when we call its FOO() method
					tmp = elem[ ontype ];

					if ( tmp ) {
						elem[ ontype ] = null;
					}

					// Prevent re-triggering of the same event, since we already bubbled it above
					jQuery.event.triggered = type;
					try {
						elem[ type ]();
					} catch ( e ) {
						// IE<9 dies on focus/blur to hidden element (#1486,#12518)
						// only reproducible on winXP IE8 native, not IE9 in IE8 mode
					}
					jQuery.event.triggered = undefined;

					if ( tmp ) {
						elem[ ontype ] = tmp;
					}
				}
			}
		}

		return event.result;
	},

	dispatch: function( event ) {

		// Make a writable jQuery.Event from the native event object
		event = jQuery.event.fix( event );

		var i, j, ret, matched, handleObj,
			handlerQueue = [],
			args = core_slice.call( arguments ),
			handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
			special = jQuery.event.special[ event.type ] || {};

		// Use the fix-ed jQuery.Event rather than the (read-only) native event
		args[0] = event;
		event.delegateTarget = this;

		// Call the preDispatch hook for the mapped type, and let it bail if desired
		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
			return;
		}

		// Determine handlers
		handlerQueue = jQuery.event.handlers.call( this, event, handlers );

		// Run delegates first; they may want to stop propagation beneath us
		i = 0;
		while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
			event.currentTarget = matched.elem;

			j = 0;
			while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {

				// Triggered event must either 1) have no namespace, or
				// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
				if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {

					event.handleObj = handleObj;
					event.data = handleObj.data;

					ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
							.apply( matched.elem, args );

					if ( ret !== undefined ) {
						if ( (event.result = ret) === false ) {
							event.preventDefault();
							event.stopPropagation();
						}
					}
				}
			}
		}

		// Call the postDispatch hook for the mapped type
		if ( special.postDispatch ) {
			special.postDispatch.call( this, event );
		}

		return event.result;
	},

	handlers: function( event, handlers ) {
		var i, matches, sel, handleObj,
			handlerQueue = [],
			delegateCount = handlers.delegateCount,
			cur = event.target;

		// Find delegate handlers
		// Black-hole SVG <use> instance trees (#13180)
		// Avoid non-left-click bubbling in Firefox (#3861)
		if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {

			for ( ; cur != this; cur = cur.parentNode || this ) {

				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
				if ( cur.disabled !== true || event.type !== "click" ) {
					matches = [];
					for ( i = 0; i < delegateCount; i++ ) {
						handleObj = handlers[ i ];

						// Don't conflict with Object.prototype properties (#13203)
						sel = handleObj.selector + " ";

						if ( matches[ sel ] === undefined ) {
							matches[ sel ] = handleObj.needsContext ?
								jQuery( sel, this ).index( cur ) >= 0 :
								jQuery.find( sel, this, null, [ cur ] ).length;
						}
						if ( matches[ sel ] ) {
							matches.push( handleObj );
						}
					}
					if ( matches.length ) {
						handlerQueue.push({ elem: cur, handlers: matches });
					}
				}
			}
		}

		// Add the remaining (directly-bound) handlers
		if ( delegateCount < handlers.length ) {
			handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });
		}

		return handlerQueue;
	},

	fix: function( event ) {
		if ( event[ jQuery.expando ] ) {
			return event;
		}

		// Create a writable copy of the event object and normalize some properties
		var i, prop,
			originalEvent = event,
			fixHook = jQuery.event.fixHooks[ event.type ] || {},
			copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;

		event = new jQuery.Event( originalEvent );

		i = copy.length;
		while ( i-- ) {
			prop = copy[ i ];
			event[ prop ] = originalEvent[ prop ];
		}

		// Support: IE<9
		// Fix target property (#1925)
		if ( !event.target ) {
			event.target = originalEvent.srcElement || document;
		}

		// Support: Chrome 23+, Safari?
		// Target should not be a text node (#504, #13143)
		if ( event.target.nodeType === 3 ) {
			event.target = event.target.parentNode;
		}

		// Support: IE<9
		// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
		event.metaKey = !!event.metaKey;

		return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
	},

	// Includes some event props shared by KeyEvent and MouseEvent
	props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),

	fixHooks: {},

	keyHooks: {
		props: "char charCode key keyCode".split(" "),
		filter: function( event, original ) {

			// Add which for key events
			if ( event.which == null ) {
				event.which = original.charCode != null ? original.charCode : original.keyCode;
			}

			return event;
		}
	},

	mouseHooks: {
		props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
		filter: function( event, original ) {
			var eventDoc, doc, body,
				button = original.button,
				fromElement = original.fromElement;

			// Calculate pageX/Y if missing and clientX/Y available
			if ( event.pageX == null && original.clientX != null ) {
				eventDoc = event.target.ownerDocument || document;
				doc = eventDoc.documentElement;
				body = eventDoc.body;

				event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
				event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
			}

			// Add relatedTarget, if necessary
			if ( !event.relatedTarget && fromElement ) {
				event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
			}

			// Add which for click: 1 === left; 2 === middle; 3 === right
			// Note: button is not normalized, so don't use it
			if ( !event.which && button !== undefined ) {
				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
			}

			return event;
		}
	},

	special: {
		load: {
			// Prevent triggered image.load events from bubbling to window.load
			noBubble: true
		},
		click: {
			// For checkbox, fire native event so checked state will be right
			trigger: function() {
				if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) {
					this.click();
					return false;
				}
			}
		},
		focus: {
			// Fire native event if possible so blur/focus sequence is correct
			trigger: function() {
				if ( this !== document.activeElement && this.focus ) {
					try {
						this.focus();
						return false;
					} catch ( e ) {
						// Support: IE<9
						// If we error on focus to hidden element (#1486, #12518),
						// let .trigger() run the handlers
					}
				}
			},
			delegateType: "focusin"
		},
		blur: {
			trigger: function() {
				if ( this === document.activeElement && this.blur ) {
					this.blur();
					return false;
				}
			},
			delegateType: "focusout"
		},

		beforeunload: {
			postDispatch: function( event ) {

				// Even when returnValue equals to undefined Firefox will still show alert
				if ( event.result !== undefined ) {
					event.originalEvent.returnValue = event.result;
				}
			}
		}
	},

	simulate: function( type, elem, event, bubble ) {
		// Piggyback on a donor event to simulate a different one.
		// Fake originalEvent to avoid donor's stopPropagation, but if the
		// simulated event prevents default then we do the same on the donor.
		var e = jQuery.extend(
			new jQuery.Event(),
			event,
			{ type: type,
				isSimulated: true,
				originalEvent: {}
			}
		);
		if ( bubble ) {
			jQuery.event.trigger( e, null, elem );
		} else {
			jQuery.event.dispatch.call( elem, e );
		}
		if ( e.isDefaultPrevented() ) {
			event.preventDefault();
		}
	}
};

jQuery.removeEvent = document.removeEventListener ?
	function( elem, type, handle ) {
		if ( elem.removeEventListener ) {
			elem.removeEventListener( type, handle, false );
		}
	} :
	function( elem, type, handle ) {
		var name = "on" + type;

		if ( elem.detachEvent ) {

			// #8545, #7054, preventing memory leaks for custom events in IE6-8
			// detachEvent needed property on element, by name of that event, to properly expose it to GC
			if ( typeof elem[ name ] === "undefined" ) {
				elem[ name ] = null;
			}

			elem.detachEvent( name, handle );
		}
	};

jQuery.Event = function( src, props ) {
	// Allow instantiation without the 'new' keyword
	if ( !(this instanceof jQuery.Event) ) {
		return new jQuery.Event( src, props );
	}

	// Event object
	if ( src && src.type ) {
		this.originalEvent = src;
		this.type = src.type;

		// Events bubbling up the document may have been marked as prevented
		// by a handler lower down the tree; reflect the correct value.
		this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
			src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;

	// Event type
	} else {
		this.type = src;
	}

	// Put explicitly provided properties onto the event object
	if ( props ) {
		jQuery.extend( this, props );
	}

	// Create a timestamp if incoming event doesn't have one
	this.timeStamp = src && src.timeStamp || jQuery.now();

	// Mark it as fixed
	this[ jQuery.expando ] = true;
};

// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
jQuery.Event.prototype = {
	isDefaultPrevented: returnFalse,
	isPropagationStopped: returnFalse,
	isImmediatePropagationStopped: returnFalse,

	preventDefault: function() {
		var e = this.originalEvent;

		this.isDefaultPrevented = returnTrue;
		if ( !e ) {
			return;
		}

		// If preventDefault exists, run it on the original event
		if ( e.preventDefault ) {
			e.preventDefault();

		// Support: IE
		// Otherwise set the returnValue property of the original event to false
		} else {
			e.returnValue = false;
		}
	},
	stopPropagation: function() {
		var e = this.originalEvent;

		this.isPropagationStopped = returnTrue;
		if ( !e ) {
			return;
		}
		// If stopPropagation exists, run it on the original event
		if ( e.stopPropagation ) {
			e.stopPropagation();
		}

		// Support: IE
		// Set the cancelBubble property of the original event to true
		e.cancelBubble = true;
	},
	stopImmediatePropagation: function() {
		this.isImmediatePropagationStopped = returnTrue;
		this.stopPropagation();
	}
};

// Create mouseenter/leave events using mouseover/out and event-time checks
jQuery.each({
	mouseenter: "mouseover",
	mouseleave: "mouseout"
}, function( orig, fix ) {
	jQuery.event.special[ orig ] = {
		delegateType: fix,
		bindType: fix,

		handle: function( event ) {
			var ret,
				target = this,
				related = event.relatedTarget,
				handleObj = event.handleObj;

			// For mousenter/leave call the handler if related is outside the target.
			// NB: No relatedTarget if the mouse left/entered the browser window
			if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
				event.type = handleObj.origType;
				ret = handleObj.handler.apply( this, arguments );
				event.type = fix;
			}
			return ret;
		}
	};
});

// IE submit delegation
if ( !jQuery.support.submitBubbles ) {

	jQuery.event.special.submit = {
		setup: function() {
			// Only need this for delegated form submit events
			if ( jQuery.nodeName( this, "form" ) ) {
				return false;
			}

			// Lazy-add a submit handler when a descendant form may potentially be submitted
			jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
				// Node name check avoids a VML-related crash in IE (#9807)
				var elem = e.target,
					form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
				if ( form && !jQuery._data( form, "submitBubbles" ) ) {
					jQuery.event.add( form, "submit._submit", function( event ) {
						event._submit_bubble = true;
					});
					jQuery._data( form, "submitBubbles", true );
				}
			});
			// return undefined since we don't need an event listener
		},

		postDispatch: function( event ) {
			// If form was submitted by the user, bubble the event up the tree
			if ( event._submit_bubble ) {
				delete event._submit_bubble;
				if ( this.parentNode && !event.isTrigger ) {
					jQuery.event.simulate( "submit", this.parentNode, event, true );
				}
			}
		},

		teardown: function() {
			// Only need this for delegated form submit events
			if ( jQuery.nodeName( this, "form" ) ) {
				return false;
			}

			// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
			jQuery.event.remove( this, "._submit" );
		}
	};
}

// IE change delegation and checkbox/radio fix
if ( !jQuery.support.changeBubbles ) {

	jQuery.event.special.change = {

		setup: function() {

			if ( rformElems.test( this.nodeName ) ) {
				// IE doesn't fire change on a check/radio until blur; trigger it on click
				// after a propertychange. Eat the blur-change in special.change.handle.
				// This still fires onchange a second time for check/radio after blur.
				if ( this.type === "checkbox" || this.type === "radio" ) {
					jQuery.event.add( this, "propertychange._change", function( event ) {
						if ( event.originalEvent.propertyName === "checked" ) {
							this._just_changed = true;
						}
					});
					jQuery.event.add( this, "click._change", function( event ) {
						if ( this._just_changed && !event.isTrigger ) {
							this._just_changed = false;
						}
						// Allow triggered, simulated change events (#11500)
						jQuery.event.simulate( "change", this, event, true );
					});
				}
				return false;
			}
			// Delegated event; lazy-add a change handler on descendant inputs
			jQuery.event.add( this, "beforeactivate._change", function( e ) {
				var elem = e.target;

				if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "changeBubbles" ) ) {
					jQuery.event.add( elem, "change._change", function( event ) {
						if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
							jQuery.event.simulate( "change", this.parentNode, event, true );
						}
					});
					jQuery._data( elem, "changeBubbles", true );
				}
			});
		},

		handle: function( event ) {
			var elem = event.target;

			// Swallow native change events from checkbox/radio, we already triggered them above
			if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
				return event.handleObj.handler.apply( this, arguments );
			}
		},

		teardown: function() {
			jQuery.event.remove( this, "._change" );

			return !rformElems.test( this.nodeName );
		}
	};
}

// Create "bubbling" focus and blur events
if ( !jQuery.support.focusinBubbles ) {
	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {

		// Attach a single capturing handler while someone wants focusin/focusout
		var attaches = 0,
			handler = function( event ) {
				jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
			};

		jQuery.event.special[ fix ] = {
			setup: function() {
				if ( attaches++ === 0 ) {
					document.addEventListener( orig, handler, true );
				}
			},
			teardown: function() {
				if ( --attaches === 0 ) {
					document.removeEventListener( orig, handler, true );
				}
			}
		};
	});
}

jQuery.fn.extend({

	on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
		var origFn, type;

		// Types can be a map of types/handlers
		if ( typeof types === "object" ) {
			// ( types-Object, selector, data )
			if ( typeof selector !== "string" ) {
				// ( types-Object, data )
				data = data || selector;
				selector = undefined;
			}
			for ( type in types ) {
				this.on( type, selector, data, types[ type ], one );
			}
			return this;
		}

		if ( data == null && fn == null ) {
			// ( types, fn )
			fn = selector;
			data = selector = undefined;
		} else if ( fn == null ) {
			if ( typeof selector === "string" ) {
				// ( types, selector, fn )
				fn = data;
				data = undefined;
			} else {
				// ( types, data, fn )
				fn = data;
				data = selector;
				selector = undefined;
			}
		}
		if ( fn === false ) {
			fn = returnFalse;
		} else if ( !fn ) {
			return this;
		}

		if ( one === 1 ) {
			origFn = fn;
			fn = function( event ) {
				// Can use an empty set, since event contains the info
				jQuery().off( event );
				return origFn.apply( this, arguments );
			};
			// Use same guid so caller can remove using origFn
			fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
		}
		return this.each( function() {
			jQuery.event.add( this, types, fn, data, selector );
		});
	},
	one: function( types, selector, data, fn ) {
		return this.on( types, selector, data, fn, 1 );
	},
	off: function( types, selector, fn ) {
		var handleObj, type;
		if ( types && types.preventDefault && types.handleObj ) {
			// ( event )  dispatched jQuery.Event
			handleObj = types.handleObj;
			jQuery( types.delegateTarget ).off(
				handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
				handleObj.selector,
				handleObj.handler
			);
			return this;
		}
		if ( typeof types === "object" ) {
			// ( types-object [, selector] )
			for ( type in types ) {
				this.off( type, selector, types[ type ] );
			}
			return this;
		}
		if ( selector === false || typeof selector === "function" ) {
			// ( types [, fn] )
			fn = selector;
			selector = undefined;
		}
		if ( fn === false ) {
			fn = returnFalse;
		}
		return this.each(function() {
			jQuery.event.remove( this, types, fn, selector );
		});
	},

	bind: function( types, data, fn ) {
		return this.on( types, null, data, fn );
	},
	unbind: function( types, fn ) {
		return this.off( types, null, fn );
	},

	delegate: function( selector, types, data, fn ) {
		return this.on( types, selector, data, fn );
	},
	undelegate: function( selector, types, fn ) {
		// ( namespace ) or ( selector, types [, fn] )
		return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
	},

	trigger: function( type, data ) {
		return this.each(function() {
			jQuery.event.trigger( type, data, this );
		});
	},
	triggerHandler: function( type, data ) {
		var elem = this[0];
		if ( elem ) {
			return jQuery.event.trigger( type, data, elem, true );
		}
	},

	hover: function( fnOver, fnOut ) {
		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
	}
});

jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
	"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {

	// Handle event binding
	jQuery.fn[ name ] = function( data, fn ) {
		return arguments.length > 0 ?
			this.on( name, null, data, fn ) :
			this.trigger( name );
	};

	if ( rkeyEvent.test( name ) ) {
		jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
	}

	if ( rmouseEvent.test( name ) ) {
		jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
	}
});
/*!
 * Sizzle CSS Selector Engine
 * Copyright 2012 jQuery Foundation and other contributors
 * Released under the MIT license
 * http://sizzlejs.com/
 */
(function( window, undefined ) {

var i,
	cachedruns,
	Expr,
	getText,
	isXML,
	compile,
	hasDuplicate,
	outermostContext,

	// Local document vars
	setDocument,
	document,
	docElem,
	documentIsXML,
	rbuggyQSA,
	rbuggyMatches,
	matches,
	contains,
	sortOrder,

	// Instance-specific data
	expando = "sizzle" + -(new Date()),
	preferredDoc = window.document,
	support = {},
	dirruns = 0,
	done = 0,
	classCache = createCache(),
	tokenCache = createCache(),
	compilerCache = createCache(),

	// General-purpose constants
	strundefined = typeof undefined,
	MAX_NEGATIVE = 1 << 31,

	// Array methods
	arr = [],
	pop = arr.pop,
	push = arr.push,
	slice = arr.slice,
	// Use a stripped-down indexOf if we can't use a native one
	indexOf = arr.indexOf || function( elem ) {
		var i = 0,
			len = this.length;
		for ( ; i < len; i++ ) {
			if ( this[i] === elem ) {
				return i;
			}
		}
		return -1;
	},


	// Regular expressions

	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
	whitespace = "[\\x20\\t\\r\\n\\f]",
	// http://www.w3.org/TR/css3-syntax/#characters
	characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",

	// Loosely modeled on CSS identifier characters
	// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
	identifier = characterEncoding.replace( "w", "w#" ),

	// Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
	operators = "([*^$|!~]?=)",
	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
		"*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",

	// Prefer arguments quoted,
	//   then not containing pseudos/brackets,
	//   then attribute selectors/non-parenthetical expressions,
	//   then anything else
	// These preferences are here to reduce the number of selectors
	//   needing tokenize in the PSEUDO preFilter
	pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)",

	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),

	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
	rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
	rpseudo = new RegExp( pseudos ),
	ridentifier = new RegExp( "^" + identifier + "$" ),

	matchExpr = {
		"ID": new RegExp( "^#(" + characterEncoding + ")" ),
		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
		"NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ),
		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
		"ATTR": new RegExp( "^" + attributes ),
		"PSEUDO": new RegExp( "^" + pseudos ),
		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
		// For use in libraries implementing .is()
		// We use this for POS matching in `select`
		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
	},

	rsibling = /[\x20\t\r\n\f]*[+~]/,

	rnative = /\{\s*\[native code\]\s*\}/,

	// Easily-parseable/retrievable ID or TAG or CLASS selectors
	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,

	rinputs = /^(?:input|select|textarea|button)$/i,
	rheader = /^h\d$/i,

	rescape = /'|\\/g,
	rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,

	// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
	runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g,
	funescape = function( _, escaped ) {
		var high = "0x" + escaped - 0x10000;
		// NaN means non-codepoint
		return high !== high ?
			escaped :
			// BMP codepoint
			high < 0 ?
				String.fromCharCode( high + 0x10000 ) :
				// Supplemental Plane codepoint (surrogate pair)
				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
	};

// Use a stripped-down slice if we can't use a native one
try {
	slice.call( docElem.childNodes, 0 )[0].nodeType;
} catch ( e ) {
	slice = function( i ) {
		var elem,
			results = [];
		for ( ; (elem = this[i]); i++ ) {
			results.push( elem );
		}
		return results;
	};
}

/**
 * For feature detection
 * @param {Function} fn The function to test for native support
 */
function isNative( fn ) {
	return rnative.test( fn + "" );
}

/**
 * Create key-value caches of limited size
 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
 *	deleting the oldest entry
 */
function createCache() {
	var cache,
		keys = [];

	return (cache = function( key, value ) {
		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
		if ( keys.push( key += " " ) > Expr.cacheLength ) {
			// Only keep the most recent entries
			delete cache[ keys.shift() ];
		}
		return (cache[ key ] = value);
	});
}

/**
 * Mark a function for special use by Sizzle
 * @param {Function} fn The function to mark
 */
function markFunction( fn ) {
	fn[ expando ] = true;
	return fn;
}

/**
 * Support testing using an element
 * @param {Function} fn Passed the created div and expects a boolean result
 */
function assert( fn ) {
	var div = document.createElement("div");

	try {
		return fn( div );
	} catch (e) {
		return false;
	} finally {
		// release memory in IE
		div = null;
	}
}

function Sizzle( selector, context, results, seed ) {
	var match, elem, m, nodeType,
		// QSA vars
		i, groups, old, nid, newContext, newSelector;

	if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
		setDocument( context );
	}

	context = context || document;
	results = results || [];

	if ( !selector || typeof selector !== "string" ) {
		return results;
	}

	if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
		return [];
	}

	if ( !documentIsXML && !seed ) {

		// Shortcuts
		if ( (match = rquickExpr.exec( selector )) ) {
			// Speed-up: Sizzle("#ID")
			if ( (m = match[1]) ) {
				if ( nodeType === 9 ) {
					elem = context.getElementById( m );
					// Check parentNode to catch when Blackberry 4.6 returns
					// nodes that are no longer in the document #6963
					if ( elem && elem.parentNode ) {
						// Handle the case where IE, Opera, and Webkit return items
						// by name instead of ID
						if ( elem.id === m ) {
							results.push( elem );
							return results;
						}
					} else {
						return results;
					}
				} else {
					// Context is not a document
					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
						contains( context, elem ) && elem.id === m ) {
						results.push( elem );
						return results;
					}
				}

			// Speed-up: Sizzle("TAG")
			} else if ( match[2] ) {
				push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) );
				return results;

			// Speed-up: Sizzle(".CLASS")
			} else if ( (m = match[3]) && support.getByClassName && context.getElementsByClassName ) {
				push.apply( results, slice.call(context.getElementsByClassName( m ), 0) );
				return results;
			}
		}

		// QSA path
		if ( support.qsa && !rbuggyQSA.test(selector) ) {
			old = true;
			nid = expando;
			newContext = context;
			newSelector = nodeType === 9 && selector;

			// qSA works strangely on Element-rooted queries
			// We can work around this by specifying an extra ID on the root
			// and working up from there (Thanks to Andrew Dupont for the technique)
			// IE 8 doesn't work on object elements
			if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
				groups = tokenize( selector );

				if ( (old = context.getAttribute("id")) ) {
					nid = old.replace( rescape, "\\$&" );
				} else {
					context.setAttribute( "id", nid );
				}
				nid = "[id='" + nid + "'] ";

				i = groups.length;
				while ( i-- ) {
					groups[i] = nid + toSelector( groups[i] );
				}
				newContext = rsibling.test( selector ) && context.parentNode || context;
				newSelector = groups.join(",");
			}

			if ( newSelector ) {
				try {
					push.apply( results, slice.call( newContext.querySelectorAll(
						newSelector
					), 0 ) );
					return results;
				} catch(qsaError) {
				} finally {
					if ( !old ) {
						context.removeAttribute("id");
					}
				}
			}
		}
	}

	// All others
	return select( selector.replace( rtrim, "$1" ), context, results, seed );
}

/**
 * Detect xml
 * @param {Element|Object} elem An element or a document
 */
isXML = Sizzle.isXML = function( elem ) {
	// documentElement is verified for cases where it doesn't yet exist
	// (such as loading iframes in IE - #4833)
	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
	return documentElement ? documentElement.nodeName !== "HTML" : false;
};

/**
 * Sets document-related variables once based on the current document
 * @param {Element|Object} [doc] An element or document object to use to set the document
 * @returns {Object} Returns the current document
 */
setDocument = Sizzle.setDocument = function( node ) {
	var doc = node ? node.ownerDocument || node : preferredDoc;

	// If no document and documentElement is available, return
	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
		return document;
	}

	// Set our document
	document = doc;
	docElem = doc.documentElement;

	// Support tests
	documentIsXML = isXML( doc );

	// Check if getElementsByTagName("*") returns only elements
	support.tagNameNoComments = assert(function( div ) {
		div.appendChild( doc.createComment("") );
		return !div.getElementsByTagName("*").length;
	});

	// Check if attributes should be retrieved by attribute nodes
	support.attributes = assert(function( div ) {
		div.innerHTML = "<select></select>";
		var type = typeof div.lastChild.getAttribute("multiple");
		// IE8 returns a string for some attributes even when not present
		return type !== "boolean" && type !== "string";
	});

	// Check if getElementsByClassName can be trusted
	support.getByClassName = assert(function( div ) {
		// Opera can't find a second classname (in 9.6)
		div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>";
		if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) {
			return false;
		}

		// Safari 3.2 caches class attributes and doesn't catch changes
		div.lastChild.className = "e";
		return div.getElementsByClassName("e").length === 2;
	});

	// Check if getElementById returns elements by name
	// Check if getElementsByName privileges form controls or returns elements by ID
	support.getByName = assert(function( div ) {
		// Inject content
		div.id = expando + 0;
		div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>";
		docElem.insertBefore( div, docElem.firstChild );

		// Test
		var pass = doc.getElementsByName &&
			// buggy browsers will return fewer than the correct 2
			doc.getElementsByName( expando ).length === 2 +
			// buggy browsers will return more than the correct 0
			doc.getElementsByName( expando + 0 ).length;
		support.getIdNotName = !doc.getElementById( expando );

		// Cleanup
		docElem.removeChild( div );

		return pass;
	});

	// IE6/7 return modified attributes
	Expr.attrHandle = assert(function( div ) {
		div.innerHTML = "<a href='#'></a>";
		return div.firstChild && typeof div.firstChild.getAttribute !== strundefined &&
			div.firstChild.getAttribute("href") === "#";
	}) ?
		{} :
		{
			"href": function( elem ) {
				return elem.getAttribute( "href", 2 );
			},
			"type": function( elem ) {
				return elem.getAttribute("type");
			}
		};

	// ID find and filter
	if ( support.getIdNotName ) {
		Expr.find["ID"] = function( id, context ) {
			if ( typeof context.getElementById !== strundefined && !documentIsXML ) {
				var m = context.getElementById( id );
				// Check parentNode to catch when Blackberry 4.6 returns
				// nodes that are no longer in the document #6963
				return m && m.parentNode ? [m] : [];
			}
		};
		Expr.filter["ID"] = function( id ) {
			var attrId = id.replace( runescape, funescape );
			return function( elem ) {
				return elem.getAttribute("id") === attrId;
			};
		};
	} else {
		Expr.find["ID"] = function( id, context ) {
			if ( typeof context.getElementById !== strundefined && !documentIsXML ) {
				var m = context.getElementById( id );

				return m ?
					m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ?
						[m] :
						undefined :
					[];
			}
		};
		Expr.filter["ID"] =  function( id ) {
			var attrId = id.replace( runescape, funescape );
			return function( elem ) {
				var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
				return node && node.value === attrId;
			};
		};
	}

	// Tag
	Expr.find["TAG"] = support.tagNameNoComments ?
		function( tag, context ) {
			if ( typeof context.getElementsByTagName !== strundefined ) {
				return context.getElementsByTagName( tag );
			}
		} :
		function( tag, context ) {
			var elem,
				tmp = [],
				i = 0,
				results = context.getElementsByTagName( tag );

			// Filter out possible comments
			if ( tag === "*" ) {
				for ( ; (elem = results[i]); i++ ) {
					if ( elem.nodeType === 1 ) {
						tmp.push( elem );
					}
				}

				return tmp;
			}
			return results;
		};

	// Name
	Expr.find["NAME"] = support.getByName && function( tag, context ) {
		if ( typeof context.getElementsByName !== strundefined ) {
			return context.getElementsByName( name );
		}
	};

	// Class
	Expr.find["CLASS"] = support.getByClassName && function( className, context ) {
		if ( typeof context.getElementsByClassName !== strundefined && !documentIsXML ) {
			return context.getElementsByClassName( className );
		}
	};

	// QSA and matchesSelector support

	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
	rbuggyMatches = [];

	// qSa(:focus) reports false when true (Chrome 21),
	// no need to also add to buggyMatches since matches checks buggyQSA
	// A support test would require too much code (would include document ready)
	rbuggyQSA = [ ":focus" ];

	if ( (support.qsa = isNative(doc.querySelectorAll)) ) {
		// Build QSA regex
		// Regex strategy adopted from Diego Perini
		assert(function( div ) {
			// Select is set to empty string on purpose
			// This is to test IE's treatment of not explictly
			// setting a boolean content attribute,
			// since its presence should be enough
			// http://bugs.jquery.com/ticket/12359
			div.innerHTML = "<select><option selected=''></option></select>";

			// IE8 - Some boolean attributes are not treated correctly
			if ( !div.querySelectorAll("[selected]").length ) {
				rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" );
			}

			// Webkit/Opera - :checked should return selected option elements
			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
			// IE8 throws error here and will not see later tests
			if ( !div.querySelectorAll(":checked").length ) {
				rbuggyQSA.push(":checked");
			}
		});

		assert(function( div ) {

			// Opera 10-12/IE8 - ^= $= *= and empty values
			// Should not select anything
			div.innerHTML = "<input type='hidden' i=''/>";
			if ( div.querySelectorAll("[i^='']").length ) {
				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" );
			}

			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
			// IE8 throws error here and will not see later tests
			if ( !div.querySelectorAll(":enabled").length ) {
				rbuggyQSA.push( ":enabled", ":disabled" );
			}

			// Opera 10-11 does not throw on post-comma invalid pseudos
			div.querySelectorAll("*,:x");
			rbuggyQSA.push(",.*:");
		});
	}

	if ( (support.matchesSelector = isNative( (matches = docElem.matchesSelector ||
		docElem.mozMatchesSelector ||
		docElem.webkitMatchesSelector ||
		docElem.oMatchesSelector ||
		docElem.msMatchesSelector) )) ) {

		assert(function( div ) {
			// Check to see if it's possible to do matchesSelector
			// on a disconnected node (IE 9)
			support.disconnectedMatch = matches.call( div, "div" );

			// This should fail with an exception
			// Gecko does not error, returns false instead
			matches.call( div, "[s!='']:x" );
			rbuggyMatches.push( "!=", pseudos );
		});
	}

	rbuggyQSA = new RegExp( rbuggyQSA.join("|") );
	rbuggyMatches = new RegExp( rbuggyMatches.join("|") );

	// Element contains another
	// Purposefully does not implement inclusive descendent
	// As in, an element does not contain itself
	contains = isNative(docElem.contains) || docElem.compareDocumentPosition ?
		function( a, b ) {
			var adown = a.nodeType === 9 ? a.documentElement : a,
				bup = b && b.parentNode;
			return a === bup || !!( bup && bup.nodeType === 1 && (
				adown.contains ?
					adown.contains( bup ) :
					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
			));
		} :
		function( a, b ) {
			if ( b ) {
				while ( (b = b.parentNode) ) {
					if ( b === a ) {
						return true;
					}
				}
			}
			return false;
		};

	// Document order sorting
	sortOrder = docElem.compareDocumentPosition ?
	function( a, b ) {
		var compare;

		if ( a === b ) {
			hasDuplicate = true;
			return 0;
		}

		if ( (compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b )) ) {
			if ( compare & 1 || a.parentNode && a.parentNode.nodeType === 11 ) {
				if ( a === doc || contains( preferredDoc, a ) ) {
					return -1;
				}
				if ( b === doc || contains( preferredDoc, b ) ) {
					return 1;
				}
				return 0;
			}
			return compare & 4 ? -1 : 1;
		}

		return a.compareDocumentPosition ? -1 : 1;
	} :
	function( a, b ) {
		var cur,
			i = 0,
			aup = a.parentNode,
			bup = b.parentNode,
			ap = [ a ],
			bp = [ b ];

		// The nodes are identical, we can exit early
		if ( a === b ) {
			hasDuplicate = true;
			return 0;

		// Fallback to using sourceIndex (in IE) if it's available on both nodes
		} else if ( a.sourceIndex && b.sourceIndex ) {
			return ( ~b.sourceIndex || MAX_NEGATIVE ) - ( contains( preferredDoc, a ) && ~a.sourceIndex || MAX_NEGATIVE );

		// Parentless nodes are either documents or disconnected
		} else if ( !aup || !bup ) {
			return a === doc ? -1 :
				b === doc ? 1 :
				aup ? -1 :
				bup ? 1 :
				0;

		// If the nodes are siblings, we can do a quick check
		} else if ( aup === bup ) {
			return siblingCheck( a, b );
		}

		// Otherwise we need full lists of their ancestors for comparison
		cur = a;
		while ( (cur = cur.parentNode) ) {
			ap.unshift( cur );
		}
		cur = b;
		while ( (cur = cur.parentNode) ) {
			bp.unshift( cur );
		}

		// Walk down the tree looking for a discrepancy
		while ( ap[i] === bp[i] ) {
			i++;
		}

		return i ?
			// Do a sibling check if the nodes have a common ancestor
			siblingCheck( ap[i], bp[i] ) :

			// Otherwise nodes in our document sort first
			ap[i] === preferredDoc ? -1 :
			bp[i] === preferredDoc ? 1 :
			0;
	};

	// Always assume the presence of duplicates if sort doesn't
	// pass them to our comparison function (as in Google Chrome).
	hasDuplicate = false;
	[0, 0].sort( sortOrder );
	support.detectDuplicates = hasDuplicate;

	return document;
};

Sizzle.matches = function( expr, elements ) {
	return Sizzle( expr, null, null, elements );
};

Sizzle.matchesSelector = function( elem, expr ) {
	// Set document vars if needed
	if ( ( elem.ownerDocument || elem ) !== document ) {
		setDocument( elem );
	}

	// Make sure that attribute selectors are quoted
	expr = expr.replace( rattributeQuotes, "='$1']" );

	// rbuggyQSA always contains :focus, so no need for an existence check
	if ( support.matchesSelector && !documentIsXML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && !rbuggyQSA.test(expr) ) {
		try {
			var ret = matches.call( elem, expr );

			// IE 9's matchesSelector returns false on disconnected nodes
			if ( ret || support.disconnectedMatch ||
					// As well, disconnected nodes are said to be in a document
					// fragment in IE 9
					elem.document && elem.document.nodeType !== 11 ) {
				return ret;
			}
		} catch(e) {}
	}

	return Sizzle( expr, document, null, [elem] ).length > 0;
};

Sizzle.contains = function( context, elem ) {
	// Set document vars if needed
	if ( ( context.ownerDocument || context ) !== document ) {
		setDocument( context );
	}
	return contains( context, elem );
};

Sizzle.attr = function( elem, name ) {
	var val;

	// Set document vars if needed
	if ( ( elem.ownerDocument || elem ) !== document ) {
		setDocument( elem );
	}

	if ( !documentIsXML ) {
		name = name.toLowerCase();
	}
	if ( (val = Expr.attrHandle[ name ]) ) {
		return val( elem );
	}
	if ( documentIsXML || support.attributes ) {
		return elem.getAttribute( name );
	}
	return ( (val = elem.getAttributeNode( name )) || elem.getAttribute( name ) ) && elem[ name ] === true ?
		name :
		val && val.specified ? val.value : null;
};

Sizzle.error = function( msg ) {
	throw new Error( "Syntax error, unrecognized expression: " + msg );
};

// Document sorting and removing duplicates
Sizzle.uniqueSort = function( results ) {
	var elem,
		duplicates = [],
		i = 1,
		j = 0;

	// Unless we *know* we can detect duplicates, assume their presence
	hasDuplicate = !support.detectDuplicates;
	results.sort( sortOrder );

	if ( hasDuplicate ) {
		for ( ; (elem = results[i]); i++ ) {
			if ( elem === results[ i - 1 ] ) {
				j = duplicates.push( i );
			}
		}
		while ( j-- ) {
			results.splice( duplicates[ j ], 1 );
		}
	}

	return results;
};

function siblingCheck( a, b ) {
	var cur = a && b && a.nextSibling;

	for ( ; cur; cur = cur.nextSibling ) {
		if ( cur === b ) {
			return -1;
		}
	}

	return a ? 1 : -1;
}

// Returns a function to use in pseudos for input types
function createInputPseudo( type ) {
	return function( elem ) {
		var name = elem.nodeName.toLowerCase();
		return name === "input" && elem.type === type;
	};
}

// Returns a function to use in pseudos for buttons
function createButtonPseudo( type ) {
	return function( elem ) {
		var name = elem.nodeName.toLowerCase();
		return (name === "input" || name === "button") && elem.type === type;
	};
}

// Returns a function to use in pseudos for positionals
function createPositionalPseudo( fn ) {
	return markFunction(function( argument ) {
		argument = +argument;
		return markFunction(function( seed, matches ) {
			var j,
				matchIndexes = fn( [], seed.length, argument ),
				i = matchIndexes.length;

			// Match elements found at the specified indexes
			while ( i-- ) {
				if ( seed[ (j = matchIndexes[i]) ] ) {
					seed[j] = !(matches[j] = seed[j]);
				}
			}
		});
	});
}

/**
 * Utility function for retrieving the text value of an array of DOM nodes
 * @param {Array|Element} elem
 */
getText = Sizzle.getText = function( elem ) {
	var node,
		ret = "",
		i = 0,
		nodeType = elem.nodeType;

	if ( !nodeType ) {
		// If no nodeType, this is expected to be an array
		for ( ; (node = elem[i]); i++ ) {
			// Do not traverse comment nodes
			ret += getText( node );
		}
	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
		// Use textContent for elements
		// innerText usage removed for consistency of new lines (see #11153)
		if ( typeof elem.textContent === "string" ) {
			return elem.textContent;
		} else {
			// Traverse its children
			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
				ret += getText( elem );
			}
		}
	} else if ( nodeType === 3 || nodeType === 4 ) {
		return elem.nodeValue;
	}
	// Do not include comment or processing instruction nodes

	return ret;
};

Expr = Sizzle.selectors = {

	// Can be adjusted by the user
	cacheLength: 50,

	createPseudo: markFunction,

	match: matchExpr,

	find: {},

	relative: {
		">": { dir: "parentNode", first: true },
		" ": { dir: "parentNode" },
		"+": { dir: "previousSibling", first: true },
		"~": { dir: "previousSibling" }
	},

	preFilter: {
		"ATTR": function( match ) {
			match[1] = match[1].replace( runescape, funescape );

			// Move the given value to match[3] whether quoted or unquoted
			match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );

			if ( match[2] === "~=" ) {
				match[3] = " " + match[3] + " ";
			}

			return match.slice( 0, 4 );
		},

		"CHILD": function( match ) {
			/* matches from matchExpr["CHILD"]
				1 type (only|nth|...)
				2 what (child|of-type)
				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
				4 xn-component of xn+y argument ([+-]?\d*n|)
				5 sign of xn-component
				6 x of xn-component
				7 sign of y-component
				8 y of y-component
			*/
			match[1] = match[1].toLowerCase();

			if ( match[1].slice( 0, 3 ) === "nth" ) {
				// nth-* requires argument
				if ( !match[3] ) {
					Sizzle.error( match[0] );
				}

				// numeric x and y parameters for Expr.filter.CHILD
				// remember that false/true cast respectively to 0/1
				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );

			// other types prohibit arguments
			} else if ( match[3] ) {
				Sizzle.error( match[0] );
			}

			return match;
		},

		"PSEUDO": function( match ) {
			var excess,
				unquoted = !match[5] && match[2];

			if ( matchExpr["CHILD"].test( match[0] ) ) {
				return null;
			}

			// Accept quoted arguments as-is
			if ( match[4] ) {
				match[2] = match[4];

			// Strip excess characters from unquoted arguments
			} else if ( unquoted && rpseudo.test( unquoted ) &&
				// Get excess from tokenize (recursively)
				(excess = tokenize( unquoted, true )) &&
				// advance to the next closing parenthesis
				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {

				// excess is a negative index
				match[0] = match[0].slice( 0, excess );
				match[2] = unquoted.slice( 0, excess );
			}

			// Return only captures needed by the pseudo filter method (type and argument)
			return match.slice( 0, 3 );
		}
	},

	filter: {

		"TAG": function( nodeName ) {
			if ( nodeName === "*" ) {
				return function() { return true; };
			}

			nodeName = nodeName.replace( runescape, funescape ).toLowerCase();
			return function( elem ) {
				return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
			};
		},

		"CLASS": function( className ) {
			var pattern = classCache[ className + " " ];

			return pattern ||
				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
				classCache( className, function( elem ) {
					return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" );
				});
		},

		"ATTR": function( name, operator, check ) {
			return function( elem ) {
				var result = Sizzle.attr( elem, name );

				if ( result == null ) {
					return operator === "!=";
				}
				if ( !operator ) {
					return true;
				}

				result += "";

				return operator === "=" ? result === check :
					operator === "!=" ? result !== check :
					operator === "^=" ? check && result.indexOf( check ) === 0 :
					operator === "*=" ? check && result.indexOf( check ) > -1 :
					operator === "$=" ? check && result.substr( result.length - check.length ) === check :
					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
					operator === "|=" ? result === check || result.substr( 0, check.length + 1 ) === check + "-" :
					false;
			};
		},

		"CHILD": function( type, what, argument, first, last ) {
			var simple = type.slice( 0, 3 ) !== "nth",
				forward = type.slice( -4 ) !== "last",
				ofType = what === "of-type";

			return first === 1 && last === 0 ?

				// Shortcut for :nth-*(n)
				function( elem ) {
					return !!elem.parentNode;
				} :

				function( elem, context, xml ) {
					var cache, outerCache, node, diff, nodeIndex, start,
						dir = simple !== forward ? "nextSibling" : "previousSibling",
						parent = elem.parentNode,
						name = ofType && elem.nodeName.toLowerCase(),
						useCache = !xml && !ofType;

					if ( parent ) {

						// :(first|last|only)-(child|of-type)
						if ( simple ) {
							while ( dir ) {
								node = elem;
								while ( (node = node[ dir ]) ) {
									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
										return false;
									}
								}
								// Reverse direction for :only-* (if we haven't yet done so)
								start = dir = type === "only" && !start && "nextSibling";
							}
							return true;
						}

						start = [ forward ? parent.firstChild : parent.lastChild ];

						// non-xml :nth-child(...) stores cache data on `parent`
						if ( forward && useCache ) {
							// Seek `elem` from a previously-cached index
							outerCache = parent[ expando ] || (parent[ expando ] = {});
							cache = outerCache[ type ] || [];
							nodeIndex = cache[0] === dirruns && cache[1];
							diff = cache[0] === dirruns && cache[2];
							node = nodeIndex && parent.childNodes[ nodeIndex ];

							while ( (node = ++nodeIndex && node && node[ dir ] ||

								// Fallback to seeking `elem` from the start
								(diff = nodeIndex = 0) || start.pop()) ) {

								// When found, cache indexes on `parent` and break
								if ( node.nodeType === 1 && ++diff && node === elem ) {
									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
									break;
								}
							}

						// Use previously-cached element index if available
						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
							diff = cache[1];

						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
						} else {
							// Use the same loop as above to seek `elem` from the start
							while ( (node = ++nodeIndex && node && node[ dir ] ||
								(diff = nodeIndex = 0) || start.pop()) ) {

								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
									// Cache the index of each encountered element
									if ( useCache ) {
										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
									}

									if ( node === elem ) {
										break;
									}
								}
							}
						}

						// Incorporate the offset, then check against cycle size
						diff -= last;
						return diff === first || ( diff % first === 0 && diff / first >= 0 );
					}
				};
		},

		"PSEUDO": function( pseudo, argument ) {
			// pseudo-class names are case-insensitive
			// http://www.w3.org/TR/selectors/#pseudo-classes
			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
			// Remember that setFilters inherits from pseudos
			var args,
				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
					Sizzle.error( "unsupported pseudo: " + pseudo );

			// The user may use createPseudo to indicate that
			// arguments are needed to create the filter function
			// just as Sizzle does
			if ( fn[ expando ] ) {
				return fn( argument );
			}

			// But maintain support for old signatures
			if ( fn.length > 1 ) {
				args = [ pseudo, pseudo, "", argument ];
				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
					markFunction(function( seed, matches ) {
						var idx,
							matched = fn( seed, argument ),
							i = matched.length;
						while ( i-- ) {
							idx = indexOf.call( seed, matched[i] );
							seed[ idx ] = !( matches[ idx ] = matched[i] );
						}
					}) :
					function( elem ) {
						return fn( elem, 0, args );
					};
			}

			return fn;
		}
	},

	pseudos: {
		// Potentially complex pseudos
		"not": markFunction(function( selector ) {
			// Trim the selector passed to compile
			// to avoid treating leading and trailing
			// spaces as combinators
			var input = [],
				results = [],
				matcher = compile( selector.replace( rtrim, "$1" ) );

			return matcher[ expando ] ?
				markFunction(function( seed, matches, context, xml ) {
					var elem,
						unmatched = matcher( seed, null, xml, [] ),
						i = seed.length;

					// Match elements unmatched by `matcher`
					while ( i-- ) {
						if ( (elem = unmatched[i]) ) {
							seed[i] = !(matches[i] = elem);
						}
					}
				}) :
				function( elem, context, xml ) {
					input[0] = elem;
					matcher( input, null, xml, results );
					return !results.pop();
				};
		}),

		"has": markFunction(function( selector ) {
			return function( elem ) {
				return Sizzle( selector, elem ).length > 0;
			};
		}),

		"contains": markFunction(function( text ) {
			return function( elem ) {
				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
			};
		}),

		// "Whether an element is represented by a :lang() selector
		// is based solely on the element's language value
		// being equal to the identifier C,
		// or beginning with the identifier C immediately followed by "-".
		// The matching of C against the element's language value is performed case-insensitively.
		// The identifier C does not have to be a valid language name."
		// http://www.w3.org/TR/selectors/#lang-pseudo
		"lang": markFunction( function( lang ) {
			// lang value must be a valid identifider
			if ( !ridentifier.test(lang || "") ) {
				Sizzle.error( "unsupported lang: " + lang );
			}
			lang = lang.replace( runescape, funescape ).toLowerCase();
			return function( elem ) {
				var elemLang;
				do {
					if ( (elemLang = documentIsXML ?
						elem.getAttribute("xml:lang") || elem.getAttribute("lang") :
						elem.lang) ) {

						elemLang = elemLang.toLowerCase();
						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
					}
				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
				return false;
			};
		}),

		// Miscellaneous
		"target": function( elem ) {
			var hash = window.location && window.location.hash;
			return hash && hash.slice( 1 ) === elem.id;
		},

		"root": function( elem ) {
			return elem === docElem;
		},

		"focus": function( elem ) {
			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
		},

		// Boolean properties
		"enabled": function( elem ) {
			return elem.disabled === false;
		},

		"disabled": function( elem ) {
			return elem.disabled === true;
		},

		"checked": function( elem ) {
			// In CSS3, :checked should return both checked and selected elements
			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
			var nodeName = elem.nodeName.toLowerCase();
			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
		},

		"selected": function( elem ) {
			// Accessing this property makes selected-by-default
			// options in Safari work properly
			if ( elem.parentNode ) {
				elem.parentNode.selectedIndex;
			}

			return elem.selected === true;
		},

		// Contents
		"empty": function( elem ) {
			// http://www.w3.org/TR/selectors/#empty-pseudo
			// :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
			//   not comment, processing instructions, or others
			// Thanks to Diego Perini for the nodeName shortcut
			//   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
				if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) {
					return false;
				}
			}
			return true;
		},

		"parent": function( elem ) {
			return !Expr.pseudos["empty"]( elem );
		},

		// Element/input types
		"header": function( elem ) {
			return rheader.test( elem.nodeName );
		},

		"input": function( elem ) {
			return rinputs.test( elem.nodeName );
		},

		"button": function( elem ) {
			var name = elem.nodeName.toLowerCase();
			return name === "input" && elem.type === "button" || name === "button";
		},

		"text": function( elem ) {
			var attr;
			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
			// use getAttribute instead to test this case
			return elem.nodeName.toLowerCase() === "input" &&
				elem.type === "text" &&
				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type );
		},

		// Position-in-collection
		"first": createPositionalPseudo(function() {
			return [ 0 ];
		}),

		"last": createPositionalPseudo(function( matchIndexes, length ) {
			return [ length - 1 ];
		}),

		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
			return [ argument < 0 ? argument + length : argument ];
		}),

		"even": createPositionalPseudo(function( matchIndexes, length ) {
			var i = 0;
			for ( ; i < length; i += 2 ) {
				matchIndexes.push( i );
			}
			return matchIndexes;
		}),

		"odd": createPositionalPseudo(function( matchIndexes, length ) {
			var i = 1;
			for ( ; i < length; i += 2 ) {
				matchIndexes.push( i );
			}
			return matchIndexes;
		}),

		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
			var i = argument < 0 ? argument + length : argument;
			for ( ; --i >= 0; ) {
				matchIndexes.push( i );
			}
			return matchIndexes;
		}),

		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
			var i = argument < 0 ? argument + length : argument;
			for ( ; ++i < length; ) {
				matchIndexes.push( i );
			}
			return matchIndexes;
		})
	}
};

// Add button/input type pseudos
for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
	Expr.pseudos[ i ] = createInputPseudo( i );
}
for ( i in { submit: true, reset: true } ) {
	Expr.pseudos[ i ] = createButtonPseudo( i );
}

function tokenize( selector, parseOnly ) {
	var matched, match, tokens, type,
		soFar, groups, preFilters,
		cached = tokenCache[ selector + " " ];

	if ( cached ) {
		return parseOnly ? 0 : cached.slice( 0 );
	}

	soFar = selector;
	groups = [];
	preFilters = Expr.preFilter;

	while ( soFar ) {

		// Comma and first run
		if ( !matched || (match = rcomma.exec( soFar )) ) {
			if ( match ) {
				// Don't consume trailing commas as valid
				soFar = soFar.slice( match[0].length ) || soFar;
			}
			groups.push( tokens = [] );
		}

		matched = false;

		// Combinators
		if ( (match = rcombinators.exec( soFar )) ) {
			matched = match.shift();
			tokens.push( {
				value: matched,
				// Cast descendant combinators to space
				type: match[0].replace( rtrim, " " )
			} );
			soFar = soFar.slice( matched.length );
		}

		// Filters
		for ( type in Expr.filter ) {
			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
				(match = preFilters[ type ]( match ))) ) {
				matched = match.shift();
				tokens.push( {
					value: matched,
					type: type,
					matches: match
				} );
				soFar = soFar.slice( matched.length );
			}
		}

		if ( !matched ) {
			break;
		}
	}

	// Return the length of the invalid excess
	// if we're just parsing
	// Otherwise, throw an error or return tokens
	return parseOnly ?
		soFar.length :
		soFar ?
			Sizzle.error( selector ) :
			// Cache the tokens
			tokenCache( selector, groups ).slice( 0 );
}

function toSelector( tokens ) {
	var i = 0,
		len = tokens.length,
		selector = "";
	for ( ; i < len; i++ ) {
		selector += tokens[i].value;
	}
	return selector;
}

function addCombinator( matcher, combinator, base ) {
	var dir = combinator.dir,
		checkNonElements = base && combinator.dir === "parentNode",
		doneName = done++;

	return combinator.first ?
		// Check against closest ancestor/preceding element
		function( elem, context, xml ) {
			while ( (elem = elem[ dir ]) ) {
				if ( elem.nodeType === 1 || checkNonElements ) {
					return matcher( elem, context, xml );
				}
			}
		} :

		// Check against all ancestor/preceding elements
		function( elem, context, xml ) {
			var data, cache, outerCache,
				dirkey = dirruns + " " + doneName;

			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
			if ( xml ) {
				while ( (elem = elem[ dir ]) ) {
					if ( elem.nodeType === 1 || checkNonElements ) {
						if ( matcher( elem, context, xml ) ) {
							return true;
						}
					}
				}
			} else {
				while ( (elem = elem[ dir ]) ) {
					if ( elem.nodeType === 1 || checkNonElements ) {
						outerCache = elem[ expando ] || (elem[ expando ] = {});
						if ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) {
							if ( (data = cache[1]) === true || data === cachedruns ) {
								return data === true;
							}
						} else {
							cache = outerCache[ dir ] = [ dirkey ];
							cache[1] = matcher( elem, context, xml ) || cachedruns;
							if ( cache[1] === true ) {
								return true;
							}
						}
					}
				}
			}
		};
}

function elementMatcher( matchers ) {
	return matchers.length > 1 ?
		function( elem, context, xml ) {
			var i = matchers.length;
			while ( i-- ) {
				if ( !matchers[i]( elem, context, xml ) ) {
					return false;
				}
			}
			return true;
		} :
		matchers[0];
}

function condense( unmatched, map, filter, context, xml ) {
	var elem,
		newUnmatched = [],
		i = 0,
		len = unmatched.length,
		mapped = map != null;

	for ( ; i < len; i++ ) {
		if ( (elem = unmatched[i]) ) {
			if ( !filter || filter( elem, context, xml ) ) {
				newUnmatched.push( elem );
				if ( mapped ) {
					map.push( i );
				}
			}
		}
	}

	return newUnmatched;
}

function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
	if ( postFilter && !postFilter[ expando ] ) {
		postFilter = setMatcher( postFilter );
	}
	if ( postFinder && !postFinder[ expando ] ) {
		postFinder = setMatcher( postFinder, postSelector );
	}
	return markFunction(function( seed, results, context, xml ) {
		var temp, i, elem,
			preMap = [],
			postMap = [],
			preexisting = results.length,

			// Get initial elements from seed or context
			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),

			// Prefilter to get matcher input, preserving a map for seed-results synchronization
			matcherIn = preFilter && ( seed || !selector ) ?
				condense( elems, preMap, preFilter, context, xml ) :
				elems,

			matcherOut = matcher ?
				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?

					// ...intermediate processing is necessary
					[] :

					// ...otherwise use results directly
					results :
				matcherIn;

		// Find primary matches
		if ( matcher ) {
			matcher( matcherIn, matcherOut, context, xml );
		}

		// Apply postFilter
		if ( postFilter ) {
			temp = condense( matcherOut, postMap );
			postFilter( temp, [], context, xml );

			// Un-match failing elements by moving them back to matcherIn
			i = temp.length;
			while ( i-- ) {
				if ( (elem = temp[i]) ) {
					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
				}
			}
		}

		if ( seed ) {
			if ( postFinder || preFilter ) {
				if ( postFinder ) {
					// Get the final matcherOut by condensing this intermediate into postFinder contexts
					temp = [];
					i = matcherOut.length;
					while ( i-- ) {
						if ( (elem = matcherOut[i]) ) {
							// Restore matcherIn since elem is not yet a final match
							temp.push( (matcherIn[i] = elem) );
						}
					}
					postFinder( null, (matcherOut = []), temp, xml );
				}

				// Move matched elements from seed to results to keep them synchronized
				i = matcherOut.length;
				while ( i-- ) {
					if ( (elem = matcherOut[i]) &&
						(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {

						seed[temp] = !(results[temp] = elem);
					}
				}
			}

		// Add elements to results, through postFinder if defined
		} else {
			matcherOut = condense(
				matcherOut === results ?
					matcherOut.splice( preexisting, matcherOut.length ) :
					matcherOut
			);
			if ( postFinder ) {
				postFinder( null, results, matcherOut, xml );
			} else {
				push.apply( results, matcherOut );
			}
		}
	});
}

function matcherFromTokens( tokens ) {
	var checkContext, matcher, j,
		len = tokens.length,
		leadingRelative = Expr.relative[ tokens[0].type ],
		implicitRelative = leadingRelative || Expr.relative[" "],
		i = leadingRelative ? 1 : 0,

		// The foundational matcher ensures that elements are reachable from top-level context(s)
		matchContext = addCombinator( function( elem ) {
			return elem === checkContext;
		}, implicitRelative, true ),
		matchAnyContext = addCombinator( function( elem ) {
			return indexOf.call( checkContext, elem ) > -1;
		}, implicitRelative, true ),
		matchers = [ function( elem, context, xml ) {
			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
				(checkContext = context).nodeType ?
					matchContext( elem, context, xml ) :
					matchAnyContext( elem, context, xml ) );
		} ];

	for ( ; i < len; i++ ) {
		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
		} else {
			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );

			// Return special upon seeing a positional matcher
			if ( matcher[ expando ] ) {
				// Find the next relative operator (if any) for proper handling
				j = ++i;
				for ( ; j < len; j++ ) {
					if ( Expr.relative[ tokens[j].type ] ) {
						break;
					}
				}
				return setMatcher(
					i > 1 && elementMatcher( matchers ),
					i > 1 && toSelector( tokens.slice( 0, i - 1 ) ).replace( rtrim, "$1" ),
					matcher,
					i < j && matcherFromTokens( tokens.slice( i, j ) ),
					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
					j < len && toSelector( tokens )
				);
			}
			matchers.push( matcher );
		}
	}

	return elementMatcher( matchers );
}

function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
	// A counter to specify which element is currently being matched
	var matcherCachedRuns = 0,
		bySet = setMatchers.length > 0,
		byElement = elementMatchers.length > 0,
		superMatcher = function( seed, context, xml, results, expandContext ) {
			var elem, j, matcher,
				setMatched = [],
				matchedCount = 0,
				i = "0",
				unmatched = seed && [],
				outermost = expandContext != null,
				contextBackup = outermostContext,
				// We must always have either seed elements or context
				elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
				// Nested matchers should use non-integer dirruns
				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.E);

			if ( outermost ) {
				outermostContext = context !== document && context;
				cachedruns = matcherCachedRuns;
			}

			// Add elements passing elementMatchers directly to results
			for ( ; (elem = elems[i]) != null; i++ ) {
				if ( byElement && elem ) {
					for ( j = 0; (matcher = elementMatchers[j]); j++ ) {
						if ( matcher( elem, context, xml ) ) {
							results.push( elem );
							break;
						}
					}
					if ( outermost ) {
						dirruns = dirrunsUnique;
						cachedruns = ++matcherCachedRuns;
					}
				}

				// Track unmatched elements for set filters
				if ( bySet ) {
					// They will have gone through all possible matchers
					if ( (elem = !matcher && elem) ) {
						matchedCount--;
					}

					// Lengthen the array for every element, matched or not
					if ( seed ) {
						unmatched.push( elem );
					}
				}
			}

			// Apply set filters to unmatched elements
			// `i` starts as a string, so matchedCount would equal "00" if there are no elements
			matchedCount += i;
			if ( bySet && i !== matchedCount ) {
				for ( j = 0; (matcher = setMatchers[j]); j++ ) {
					matcher( unmatched, setMatched, context, xml );
				}

				if ( seed ) {
					// Reintegrate element matches to eliminate the need for sorting
					if ( matchedCount > 0 ) {
						while ( i-- ) {
							if ( !(unmatched[i] || setMatched[i]) ) {
								setMatched[i] = pop.call( results );
							}
						}
					}

					// Discard index placeholder values to get only actual matches
					setMatched = condense( setMatched );
				}

				// Add matches to results
				push.apply( results, setMatched );

				// Seedless set matches succeeding multiple successful matchers stipulate sorting
				if ( outermost && !seed && setMatched.length > 0 &&
					( matchedCount + setMatchers.length ) > 1 ) {

					Sizzle.uniqueSort( results );
				}
			}

			// Override manipulation of globals by nested matchers
			if ( outermost ) {
				dirruns = dirrunsUnique;
				outermostContext = contextBackup;
			}

			return unmatched;
		};

	return bySet ?
		markFunction( superMatcher ) :
		superMatcher;
}

compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
	var i,
		setMatchers = [],
		elementMatchers = [],
		cached = compilerCache[ selector + " " ];

	if ( !cached ) {
		// Generate a function of recursive functions that can be used to check each element
		if ( !group ) {
			group = tokenize( selector );
		}
		i = group.length;
		while ( i-- ) {
			cached = matcherFromTokens( group[i] );
			if ( cached[ expando ] ) {
				setMatchers.push( cached );
			} else {
				elementMatchers.push( cached );
			}
		}

		// Cache the compiled function
		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
	}
	return cached;
};

function multipleContexts( selector, contexts, results ) {
	var i = 0,
		len = contexts.length;
	for ( ; i < len; i++ ) {
		Sizzle( selector, contexts[i], results );
	}
	return results;
}

function select( selector, context, results, seed ) {
	var i, tokens, token, type, find,
		match = tokenize( selector );

	if ( !seed ) {
		// Try to minimize operations if there is only one group
		if ( match.length === 1 ) {

			// Take a shortcut and set the context if the root selector is an ID
			tokens = match[0] = match[0].slice( 0 );
			if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
					context.nodeType === 9 && !documentIsXML &&
					Expr.relative[ tokens[1].type ] ) {

				context = Expr.find["ID"]( token.matches[0].replace( runescape, funescape ), context )[0];
				if ( !context ) {
					return results;
				}

				selector = selector.slice( tokens.shift().value.length );
			}

			// Fetch a seed set for right-to-left matching
			for ( i = matchExpr["needsContext"].test( selector ) ? -1 : tokens.length - 1; i >= 0; i-- ) {
				token = tokens[i];

				// Abort if we hit a combinator
				if ( Expr.relative[ (type = token.type) ] ) {
					break;
				}
				if ( (find = Expr.find[ type ]) ) {
					// Search, expanding context for leading sibling combinators
					if ( (seed = find(
						token.matches[0].replace( runescape, funescape ),
						rsibling.test( tokens[0].type ) && context.parentNode || context
					)) ) {

						// If seed is empty or no tokens remain, we can return early
						tokens.splice( i, 1 );
						selector = seed.length && toSelector( tokens );
						if ( !selector ) {
							push.apply( results, slice.call( seed, 0 ) );
							return results;
						}

						break;
					}
				}
			}
		}
	}

	// Compile and execute a filtering function
	// Provide `match` to avoid retokenization if we modified the selector above
	compile( selector, match )(
		seed,
		context,
		documentIsXML,
		results,
		rsibling.test( selector )
	);
	return results;
}

// Deprecated
Expr.pseudos["nth"] = Expr.pseudos["eq"];

// Easy API for creating new setFilters
function setFilters() {}
Expr.filters = setFilters.prototype = Expr.pseudos;
Expr.setFilters = new setFilters();

// Initialize with the default document
setDocument();

// Override sizzle attribute retrieval
Sizzle.attr = jQuery.attr;
jQuery.find = Sizzle;
jQuery.expr = Sizzle.selectors;
jQuery.expr[":"] = jQuery.expr.pseudos;
jQuery.unique = Sizzle.uniqueSort;
jQuery.text = Sizzle.getText;
jQuery.isXMLDoc = Sizzle.isXML;
jQuery.contains = Sizzle.contains;


})( window );
var runtil = /Until$/,
	rparentsprev = /^(?:parents|prev(?:Until|All))/,
	isSimple = /^.[^:#\[\.,]*$/,
	rneedsContext = jQuery.expr.match.needsContext,
	// methods guaranteed to produce a unique set when starting from a unique set
	guaranteedUnique = {
		children: true,
		contents: true,
		next: true,
		prev: true
	};

jQuery.fn.extend({
	find: function( selector ) {
		var i, ret, self;

		if ( typeof selector !== "string" ) {
			self = this;
			return this.pushStack( jQuery( selector ).filter(function() {
				for ( i = 0; i < self.length; i++ ) {
					if ( jQuery.contains( self[ i ], this ) ) {
						return true;
					}
				}
			}) );
		}

		ret = [];
		for ( i = 0; i < this.length; i++ ) {
			jQuery.find( selector, this[ i ], ret );
		}

		// Needed because $( selector, context ) becomes $( context ).find( selector )
		ret = this.pushStack( jQuery.unique( ret ) );
		ret.selector = ( this.selector ? this.selector + " " : "" ) + selector;
		return ret;
	},

	has: function( target ) {
		var i,
			targets = jQuery( target, this ),
			len = targets.length;

		return this.filter(function() {
			for ( i = 0; i < len; i++ ) {
				if ( jQuery.contains( this, targets[i] ) ) {
					return true;
				}
			}
		});
	},

	not: function( selector ) {
		return this.pushStack( winnow(this, selector, false) );
	},

	filter: function( selector ) {
		return this.pushStack( winnow(this, selector, true) );
	},

	is: function( selector ) {
		return !!selector && (
			typeof selector === "string" ?
				// If this is a positional/relative selector, check membership in the returned set
				// so $("p:first").is("p:last") won't return true for a doc with two "p".
				rneedsContext.test( selector ) ?
					jQuery( selector, this.context ).index( this[0] ) >= 0 :
					jQuery.filter( selector, this ).length > 0 :
				this.filter( selector ).length > 0 );
	},

	closest: function( selectors, context ) {
		var cur,
			i = 0,
			l = this.length,
			ret = [],
			pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
				jQuery( selectors, context || this.context ) :
				0;

		for ( ; i < l; i++ ) {
			cur = this[i];

			while ( cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11 ) {
				if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
					ret.push( cur );
					break;
				}
				cur = cur.parentNode;
			}
		}

		return this.pushStack( ret.length > 1 ? jQuery.unique( ret ) : ret );
	},

	// Determine the position of an element within
	// the matched set of elements
	index: function( elem ) {

		// No argument, return index in parent
		if ( !elem ) {
			return ( this[0] && this[0].parentNode ) ? this.first().prevAll().length : -1;
		}

		// index in selector
		if ( typeof elem === "string" ) {
			return jQuery.inArray( this[0], jQuery( elem ) );
		}

		// Locate the position of the desired element
		return jQuery.inArray(
			// If it receives a jQuery object, the first element is used
			elem.jquery ? elem[0] : elem, this );
	},

	add: function( selector, context ) {
		var set = typeof selector === "string" ?
				jQuery( selector, context ) :
				jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
			all = jQuery.merge( this.get(), set );

		return this.pushStack( jQuery.unique(all) );
	},

	addBack: function( selector ) {
		return this.add( selector == null ?
			this.prevObject : this.prevObject.filter(selector)
		);
	}
});

jQuery.fn.andSelf = jQuery.fn.addBack;

function sibling( cur, dir ) {
	do {
		cur = cur[ dir ];
	} while ( cur && cur.nodeType !== 1 );

	return cur;
}

jQuery.each({
	parent: function( elem ) {
		var parent = elem.parentNode;
		return parent && parent.nodeType !== 11 ? parent : null;
	},
	parents: function( elem ) {
		return jQuery.dir( elem, "parentNode" );
	},
	parentsUntil: function( elem, i, until ) {
		return jQuery.dir( elem, "parentNode", until );
	},
	next: function( elem ) {
		return sibling( elem, "nextSibling" );
	},
	prev: function( elem ) {
		return sibling( elem, "previousSibling" );
	},
	nextAll: function( elem ) {
		return jQuery.dir( elem, "nextSibling" );
	},
	prevAll: function( elem ) {
		return jQuery.dir( elem, "previousSibling" );
	},
	nextUntil: function( elem, i, until ) {
		return jQuery.dir( elem, "nextSibling", until );
	},
	prevUntil: function( elem, i, until ) {
		return jQuery.dir( elem, "previousSibling", until );
	},
	siblings: function( elem ) {
		return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
	},
	children: function( elem ) {
		return jQuery.sibling( elem.firstChild );
	},
	contents: function( elem ) {
		return jQuery.nodeName( elem, "iframe" ) ?
			elem.contentDocument || elem.contentWindow.document :
			jQuery.merge( [], elem.childNodes );
	}
}, function( name, fn ) {
	jQuery.fn[ name ] = function( until, selector ) {
		var ret = jQuery.map( this, fn, until );

		if ( !runtil.test( name ) ) {
			selector = until;
		}

		if ( selector && typeof selector === "string" ) {
			ret = jQuery.filter( selector, ret );
		}

		ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;

		if ( this.length > 1 && rparentsprev.test( name ) ) {
			ret = ret.reverse();
		}

		return this.pushStack( ret );
	};
});

jQuery.extend({
	filter: function( expr, elems, not ) {
		if ( not ) {
			expr = ":not(" + expr + ")";
		}

		return elems.length === 1 ?
			jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
			jQuery.find.matches(expr, elems);
	},

	dir: function( elem, dir, until ) {
		var matched = [],
			cur = elem[ dir ];

		while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
			if ( cur.nodeType === 1 ) {
				matched.push( cur );
			}
			cur = cur[dir];
		}
		return matched;
	},

	sibling: function( n, elem ) {
		var r = [];

		for ( ; n; n = n.nextSibling ) {
			if ( n.nodeType === 1 && n !== elem ) {
				r.push( n );
			}
		}

		return r;
	}
});

// Implement the identical functionality for filter and not
function winnow( elements, qualifier, keep ) {

	// Can't pass null or undefined to indexOf in Firefox 4
	// Set to 0 to skip string check
	qualifier = qualifier || 0;

	if ( jQuery.isFunction( qualifier ) ) {
		return jQuery.grep(elements, function( elem, i ) {
			var retVal = !!qualifier.call( elem, i, elem );
			return retVal === keep;
		});

	} else if ( qualifier.nodeType ) {
		return jQuery.grep(elements, function( elem ) {
			return ( elem === qualifier ) === keep;
		});

	} else if ( typeof qualifier === "string" ) {
		var filtered = jQuery.grep(elements, function( elem ) {
			return elem.nodeType === 1;
		});

		if ( isSimple.test( qualifier ) ) {
			return jQuery.filter(qualifier, filtered, !keep);
		} else {
			qualifier = jQuery.filter( qualifier, filtered );
		}
	}

	return jQuery.grep(elements, function( elem ) {
		return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
	});
}
function createSafeFragment( document ) {
	var list = nodeNames.split( "|" ),
		safeFrag = document.createDocumentFragment();

	if ( safeFrag.createElement ) {
		while ( list.length ) {
			safeFrag.createElement(
				list.pop()
			);
		}
	}
	return safeFrag;
}

var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
		"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
	rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
	rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"),
	rleadingWhitespace = /^\s+/,
	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
	rtagName = /<([\w:]+)/,
	rtbody = /<tbody/i,
	rhtml = /<|&#?\w+;/,
	rnoInnerhtml = /<(?:script|style|link)/i,
	manipulation_rcheckableType = /^(?:checkbox|radio)$/i,
	// checked="checked" or checked
	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
	rscriptType = /^$|\/(?:java|ecma)script/i,
	rscriptTypeMasked = /^true\/(.*)/,
	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,

	// We have to close these tags to support XHTML (#13200)
	wrapMap = {
		option: [ 1, "<select multiple='multiple'>", "</select>" ],
		legend: [ 1, "<fieldset>", "</fieldset>" ],
		area: [ 1, "<map>", "</map>" ],
		param: [ 1, "<object>", "</object>" ],
		thead: [ 1, "<table>", "</table>" ],
		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],

		// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
		// unless wrapped in a div with non-breaking characters in front of it.
		_default: jQuery.support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>"  ]
	},
	safeFragment = createSafeFragment( document ),
	fragmentDiv = safeFragment.appendChild( document.createElement("div") );

wrapMap.optgroup = wrapMap.option;
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
wrapMap.th = wrapMap.td;

jQuery.fn.extend({
	text: function( value ) {
		return jQuery.access( this, function( value ) {
			return value === undefined ?
				jQuery.text( this ) :
				this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
		}, null, value, arguments.length );
	},

	wrapAll: function( html ) {
		if ( jQuery.isFunction( html ) ) {
			return this.each(function(i) {
				jQuery(this).wrapAll( html.call(this, i) );
			});
		}

		if ( this[0] ) {
			// The elements to wrap the target around
			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);

			if ( this[0].parentNode ) {
				wrap.insertBefore( this[0] );
			}

			wrap.map(function() {
				var elem = this;

				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
					elem = elem.firstChild;
				}

				return elem;
			}).append( this );
		}

		return this;
	},

	wrapInner: function( html ) {
		if ( jQuery.isFunction( html ) ) {
			return this.each(function(i) {
				jQuery(this).wrapInner( html.call(this, i) );
			});
		}

		return this.each(function() {
			var self = jQuery( this ),
				contents = self.contents();

			if ( contents.length ) {
				contents.wrapAll( html );

			} else {
				self.append( html );
			}
		});
	},

	wrap: function( html ) {
		var isFunction = jQuery.isFunction( html );

		return this.each(function(i) {
			jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
		});
	},

	unwrap: function() {
		return this.parent().each(function() {
			if ( !jQuery.nodeName( this, "body" ) ) {
				jQuery( this ).replaceWith( this.childNodes );
			}
		}).end();
	},

	append: function() {
		return this.domManip(arguments, true, function( elem ) {
			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
				this.appendChild( elem );
			}
		});
	},

	prepend: function() {
		return this.domManip(arguments, true, function( elem ) {
			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
				this.insertBefore( elem, this.firstChild );
			}
		});
	},

	before: function() {
		return this.domManip( arguments, false, function( elem ) {
			if ( this.parentNode ) {
				this.parentNode.insertBefore( elem, this );
			}
		});
	},

	after: function() {
		return this.domManip( arguments, false, function( elem ) {
			if ( this.parentNode ) {
				this.parentNode.insertBefore( elem, this.nextSibling );
			}
		});
	},

	// keepData is for internal use only--do not document
	remove: function( selector, keepData ) {
		var elem,
			i = 0;

		for ( ; (elem = this[i]) != null; i++ ) {
			if ( !selector || jQuery.filter( selector, [ elem ] ).length > 0 ) {
				if ( !keepData && elem.nodeType === 1 ) {
					jQuery.cleanData( getAll( elem ) );
				}

				if ( elem.parentNode ) {
					if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
						setGlobalEval( getAll( elem, "script" ) );
					}
					elem.parentNode.removeChild( elem );
				}
			}
		}

		return this;
	},

	empty: function() {
		var elem,
			i = 0;

		for ( ; (elem = this[i]) != null; i++ ) {
			// Remove element nodes and prevent memory leaks
			if ( elem.nodeType === 1 ) {
				jQuery.cleanData( getAll( elem, false ) );
			}

			// Remove any remaining nodes
			while ( elem.firstChild ) {
				elem.removeChild( elem.firstChild );
			}

			// If this is a select, ensure that it displays empty (#12336)
			// Support: IE<9
			if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
				elem.options.length = 0;
			}
		}

		return this;
	},

	clone: function( dataAndEvents, deepDataAndEvents ) {
		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;

		return this.map( function () {
			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
		});
	},

	html: function( value ) {
		return jQuery.access( this, function( value ) {
			var elem = this[0] || {},
				i = 0,
				l = this.length;

			if ( value === undefined ) {
				return elem.nodeType === 1 ?
					elem.innerHTML.replace( rinlinejQuery, "" ) :
					undefined;
			}

			// See if we can take a shortcut and just use innerHTML
			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
				( jQuery.support.htmlSerialize || !rnoshimcache.test( value )  ) &&
				( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
				!wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) {

				value = value.replace( rxhtmlTag, "<$1></$2>" );

				try {
					for (; i < l; i++ ) {
						// Remove element nodes and prevent memory leaks
						elem = this[i] || {};
						if ( elem.nodeType === 1 ) {
							jQuery.cleanData( getAll( elem, false ) );
							elem.innerHTML = value;
						}
					}

					elem = 0;

				// If using innerHTML throws an exception, use the fallback method
				} catch(e) {}
			}

			if ( elem ) {
				this.empty().append( value );
			}
		}, null, value, arguments.length );
	},

	replaceWith: function( value ) {
		var isFunc = jQuery.isFunction( value );

		// Make sure that the elements are removed from the DOM before they are inserted
		// this can help fix replacing a parent with child elements
		if ( !isFunc && typeof value !== "string" ) {
			value = jQuery( value ).not( this ).detach();
		}

		return this.domManip( [ value ], true, function( elem ) {
			var next = this.nextSibling,
				parent = this.parentNode;

			if ( parent && this.nodeType === 1 || this.nodeType === 11 ) {

				jQuery( this ).remove();

				if ( next ) {
					next.parentNode.insertBefore( elem, next );
				} else {
					parent.appendChild( elem );
				}
			}
		});
	},

	detach: function( selector ) {
		return this.remove( selector, true );
	},

	domManip: function( args, table, callback ) {

		// Flatten any nested arrays
		args = core_concat.apply( [], args );

		var fragment, first, scripts, hasScripts, node, doc,
			i = 0,
			l = this.length,
			set = this,
			iNoClone = l - 1,
			value = args[0],
			isFunction = jQuery.isFunction( value );

		// We can't cloneNode fragments that contain checked, in WebKit
		if ( isFunction || !( l <= 1 || typeof value !== "string" || jQuery.support.checkClone || !rchecked.test( value ) ) ) {
			return this.each(function( index ) {
				var self = set.eq( index );
				if ( isFunction ) {
					args[0] = value.call( this, index, table ? self.html() : undefined );
				}
				self.domManip( args, table, callback );
			});
		}

		if ( l ) {
			fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
			first = fragment.firstChild;

			if ( fragment.childNodes.length === 1 ) {
				fragment = first;
			}

			if ( first ) {
				table = table && jQuery.nodeName( first, "tr" );
				scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
				hasScripts = scripts.length;

				// Use the original fragment for the last item instead of the first because it can end up
				// being emptied incorrectly in certain situations (#8070).
				for ( ; i < l; i++ ) {
					node = fragment;

					if ( i !== iNoClone ) {
						node = jQuery.clone( node, true, true );

						// Keep references to cloned scripts for later restoration
						if ( hasScripts ) {
							jQuery.merge( scripts, getAll( node, "script" ) );
						}
					}

					callback.call(
						table && jQuery.nodeName( this[i], "table" ) ?
							findOrAppend( this[i], "tbody" ) :
							this[i],
						node,
						i
					);
				}

				if ( hasScripts ) {
					doc = scripts[ scripts.length - 1 ].ownerDocument;

					// Reenable scripts
					jQuery.map( scripts, restoreScript );

					// Evaluate executable scripts on first document insertion
					for ( i = 0; i < hasScripts; i++ ) {
						node = scripts[ i ];
						if ( rscriptType.test( node.type || "" ) &&
							!jQuery._data( node, "globalEval" ) && jQuery.contains( doc, node ) ) {

							if ( node.src ) {
								// Hope ajax is available...
								jQuery.ajax({
									url: node.src,
									type: "GET",
									dataType: "script",
									async: false,
									global: false,
									"throws": true
								});
							} else {
								jQuery.globalEval( ( node.text || node.textContent || node.innerHTML || "" ).replace( rcleanScript, "" ) );
							}
						}
					}
				}

				// Fix #11809: Avoid leaking memory
				fragment = first = null;
			}
		}

		return this;
	}
});

function findOrAppend( elem, tag ) {
	return elem.getElementsByTagName( tag )[0] || elem.appendChild( elem.ownerDocument.createElement( tag ) );
}

// Replace/restore the type attribute of script elements for safe DOM manipulation
function disableScript( elem ) {
	var attr = elem.getAttributeNode("type");
	elem.type = ( attr && attr.specified ) + "/" + elem.type;
	return elem;
}
function restoreScript( elem ) {
	var match = rscriptTypeMasked.exec( elem.type );
	if ( match ) {
		elem.type = match[1];
	} else {
		elem.removeAttribute("type");
	}
	return elem;
}

// Mark scripts as having already been evaluated
function setGlobalEval( elems, refElements ) {
	var elem,
		i = 0;
	for ( ; (elem = elems[i]) != null; i++ ) {
		jQuery._data( elem, "globalEval", !refElements || jQuery._data( refElements[i], "globalEval" ) );
	}
}

function cloneCopyEvent( src, dest ) {

	if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
		return;
	}

	var type, i, l,
		oldData = jQuery._data( src ),
		curData = jQuery._data( dest, oldData ),
		events = oldData.events;

	if ( events ) {
		delete curData.handle;
		curData.events = {};

		for ( type in events ) {
			for ( i = 0, l = events[ type ].length; i < l; i++ ) {
				jQuery.event.add( dest, type, events[ type ][ i ] );
			}
		}
	}

	// make the cloned public data object a copy from the original
	if ( curData.data ) {
		curData.data = jQuery.extend( {}, curData.data );
	}
}

function fixCloneNodeIssues( src, dest ) {
	var nodeName, data, e;

	// We do not need to do anything for non-Elements
	if ( dest.nodeType !== 1 ) {
		return;
	}

	nodeName = dest.nodeName.toLowerCase();

	// IE6-8 copies events bound via attachEvent when using cloneNode.
	if ( !jQuery.support.noCloneEvent && dest[ jQuery.expando ] ) {
		data = jQuery._data( dest );

		for ( e in data.events ) {
			jQuery.removeEvent( dest, e, data.handle );
		}

		// Event data gets referenced instead of copied if the expando gets copied too
		dest.removeAttribute( jQuery.expando );
	}

	// IE blanks contents when cloning scripts, and tries to evaluate newly-set text
	if ( nodeName === "script" && dest.text !== src.text ) {
		disableScript( dest ).text = src.text;
		restoreScript( dest );

	// IE6-10 improperly clones children of object elements using classid.
	// IE10 throws NoModificationAllowedError if parent is null, #12132.
	} else if ( nodeName === "object" ) {
		if ( dest.parentNode ) {
			dest.outerHTML = src.outerHTML;
		}

		// This path appears unavoidable for IE9. When cloning an object
		// element in IE9, the outerHTML strategy above is not sufficient.
		// If the src has innerHTML and the destination does not,
		// copy the src.innerHTML into the dest.innerHTML. #10324
		if ( jQuery.support.html5Clone && ( src.innerHTML && !jQuery.trim(dest.innerHTML) ) ) {
			dest.innerHTML = src.innerHTML;
		}

	} else if ( nodeName === "input" && manipulation_rcheckableType.test( src.type ) ) {
		// IE6-8 fails to persist the checked state of a cloned checkbox
		// or radio button. Worse, IE6-7 fail to give the cloned element
		// a checked appearance if the defaultChecked value isn't also set

		dest.defaultChecked = dest.checked = src.checked;

		// IE6-7 get confused and end up setting the value of a cloned
		// checkbox/radio button to an empty string instead of "on"
		if ( dest.value !== src.value ) {
			dest.value = src.value;
		}

	// IE6-8 fails to return the selected option to the default selected
	// state when cloning options
	} else if ( nodeName === "option" ) {
		dest.defaultSelected = dest.selected = src.defaultSelected;

	// IE6-8 fails to set the defaultValue to the correct value when
	// cloning other types of input fields
	} else if ( nodeName === "input" || nodeName === "textarea" ) {
		dest.defaultValue = src.defaultValue;
	}
}

jQuery.each({
	appendTo: "append",
	prependTo: "prepend",
	insertBefore: "before",
	insertAfter: "after",
	replaceAll: "replaceWith"
}, function( name, original ) {
	jQuery.fn[ name ] = function( selector ) {
		var elems,
			i = 0,
			ret = [],
			insert = jQuery( selector ),
			last = insert.length - 1;

		for ( ; i <= last; i++ ) {
			elems = i === last ? this : this.clone(true);
			jQuery( insert[i] )[ original ]( elems );

			// Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
			core_push.apply( ret, elems.get() );
		}

		return this.pushStack( ret );
	};
});

function getAll( context, tag ) {
	var elems, elem,
		i = 0,
		found = typeof context.getElementsByTagName !== "undefined" ? context.getElementsByTagName( tag || "*" ) :
			typeof context.querySelectorAll !== "undefined" ? context.querySelectorAll( tag || "*" ) :
			undefined;

	if ( !found ) {
		for ( found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++ ) {
			if ( !tag || jQuery.nodeName( elem, tag ) ) {
				found.push( elem );
			} else {
				jQuery.merge( found, getAll( elem, tag ) );
			}
		}
	}

	return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
		jQuery.merge( [ context ], found ) :
		found;
}

// Used in buildFragment, fixes the defaultChecked property
function fixDefaultChecked( elem ) {
	if ( manipulation_rcheckableType.test( elem.type ) ) {
		elem.defaultChecked = elem.checked;
	}
}

jQuery.extend({
	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
		var destElements, srcElements, node, i, clone,
			inPage = jQuery.contains( elem.ownerDocument, elem );

		if ( jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
			clone = elem.cloneNode( true );

		// IE<=8 does not properly clone detached, unknown element nodes
		} else {
			fragmentDiv.innerHTML = elem.outerHTML;
			fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
		}

		if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
				(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {

			// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
			destElements = getAll( clone );
			srcElements = getAll( elem );

			// Fix all IE cloning issues
			for ( i = 0; (node = srcElements[i]) != null; ++i ) {
				// Ensure that the destination node is not null; Fixes #9587
				if ( destElements[i] ) {
					fixCloneNodeIssues( node, destElements[i] );
				}
			}
		}

		// Copy the events from the original to the clone
		if ( dataAndEvents ) {
			if ( deepDataAndEvents ) {
				srcElements = srcElements || getAll( elem );
				destElements = destElements || getAll( clone );

				for ( i = 0; (node = srcElements[i]) != null; i++ ) {
					cloneCopyEvent( node, destElements[i] );
				}
			} else {
				cloneCopyEvent( elem, clone );
			}
		}

		// Preserve script evaluation history
		destElements = getAll( clone, "script" );
		if ( destElements.length > 0 ) {
			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
		}

		destElements = srcElements = node = null;

		// Return the cloned set
		return clone;
	},

	buildFragment: function( elems, context, scripts, selection ) {
		var contains, elem, tag, tmp, wrap, tbody, j,
			l = elems.length,

			// Ensure a safe fragment
			safe = createSafeFragment( context ),

			nodes = [],
			i = 0;

		for ( ; i < l; i++ ) {
			elem = elems[ i ];

			if ( elem || elem === 0 ) {

				// Add nodes directly
				if ( jQuery.type( elem ) === "object" ) {
					jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );

				// Convert non-html into a text node
				} else if ( !rhtml.test( elem ) ) {
					nodes.push( context.createTextNode( elem ) );

				// Convert html into DOM nodes
				} else {
					tmp = tmp || safe.appendChild( context.createElement("div") );

					// Deserialize a standard representation
					tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase();
					wrap = wrapMap[ tag ] || wrapMap._default;

					tmp.innerHTML = wrap[1] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[2];

					// Descend through wrappers to the right content
					j = wrap[0];
					while ( j-- ) {
						tmp = tmp.lastChild;
					}

					// Manually add leading whitespace removed by IE
					if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
						nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) );
					}

					// Remove IE's autoinserted <tbody> from table fragments
					if ( !jQuery.support.tbody ) {

						// String was a <table>, *may* have spurious <tbody>
						elem = tag === "table" && !rtbody.test( elem ) ?
							tmp.firstChild :

							// String was a bare <thead> or <tfoot>
							wrap[1] === "<table>" && !rtbody.test( elem ) ?
								tmp :
								0;

						j = elem && elem.childNodes.length;
						while ( j-- ) {
							if ( jQuery.nodeName( (tbody = elem.childNodes[j]), "tbody" ) && !tbody.childNodes.length ) {
								elem.removeChild( tbody );
							}
						}
					}

					jQuery.merge( nodes, tmp.childNodes );

					// Fix #12392 for WebKit and IE > 9
					tmp.textContent = "";

					// Fix #12392 for oldIE
					while ( tmp.firstChild ) {
						tmp.removeChild( tmp.firstChild );
					}

					// Remember the top-level container for proper cleanup
					tmp = safe.lastChild;
				}
			}
		}

		// Fix #11356: Clear elements from fragment
		if ( tmp ) {
			safe.removeChild( tmp );
		}

		// Reset defaultChecked for any radios and checkboxes
		// about to be appended to the DOM in IE 6/7 (#8060)
		if ( !jQuery.support.appendChecked ) {
			jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
		}

		i = 0;
		while ( (elem = nodes[ i++ ]) ) {

			// #4087 - If origin and destination elements are the same, and this is
			// that element, do not do anything
			if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
				continue;
			}

			contains = jQuery.contains( elem.ownerDocument, elem );

			// Append to fragment
			tmp = getAll( safe.appendChild( elem ), "script" );

			// Preserve script evaluation history
			if ( contains ) {
				setGlobalEval( tmp );
			}

			// Capture executables
			if ( scripts ) {
				j = 0;
				while ( (elem = tmp[ j++ ]) ) {
					if ( rscriptType.test( elem.type || "" ) ) {
						scripts.push( elem );
					}
				}
			}
		}

		tmp = null;

		return safe;
	},

	cleanData: function( elems, /* internal */ acceptData ) {
		var data, id, elem, type,
			i = 0,
			internalKey = jQuery.expando,
			cache = jQuery.cache,
			deleteExpando = jQuery.support.deleteExpando,
			special = jQuery.event.special;

		for ( ; (elem = elems[i]) != null; i++ ) {

			if ( acceptData || jQuery.acceptData( elem ) ) {

				id = elem[ internalKey ];
				data = id && cache[ id ];

				if ( data ) {
					if ( data.events ) {
						for ( type in data.events ) {
							if ( special[ type ] ) {
								jQuery.event.remove( elem, type );

							// This is a shortcut to avoid jQuery.event.remove's overhead
							} else {
								jQuery.removeEvent( elem, type, data.handle );
							}
						}
					}

					// Remove cache only if it was not already removed by jQuery.event.remove
					if ( cache[ id ] ) {

						delete cache[ id ];

						// IE does not allow us to delete expando properties from nodes,
						// nor does it have a removeAttribute function on Document nodes;
						// we must handle all of these cases
						if ( deleteExpando ) {
							delete elem[ internalKey ];

						} else if ( typeof elem.removeAttribute !== "undefined" ) {
							elem.removeAttribute( internalKey );

						} else {
							elem[ internalKey ] = null;
						}

						core_deletedIds.push( id );
					}
				}
			}
		}
	}
});
var curCSS, getStyles, iframe,
	ralpha = /alpha\([^)]*\)/i,
	ropacity = /opacity\s*=\s*([^)]*)/,
	rposition = /^(top|right|bottom|left)$/,
	// swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
	// see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
	rmargin = /^margin/,
	rnumsplit = new RegExp( "^(" + core_pnum + ")(.*)$", "i" ),
	rnumnonpx = new RegExp( "^(" + core_pnum + ")(?!px)[a-z%]+$", "i" ),
	rrelNum = new RegExp( "^([+-])=(" + core_pnum + ")", "i" ),
	elemdisplay = { BODY: "block" },

	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
	cssNormalTransform = {
		letterSpacing: 0,
		fontWeight: 400
	},

	cssExpand = [ "Top", "Right", "Bottom", "Left" ],
	cssPrefixes = [ "Webkit", "O", "Moz", "ms" ];

// return a css property mapped to a potentially vendor prefixed property
function vendorPropName( style, name ) {

	// shortcut for names that are not vendor prefixed
	if ( name in style ) {
		return name;
	}

	// check for vendor prefixed names
	var capName = name.charAt(0).toUpperCase() + name.slice(1),
		origName = name,
		i = cssPrefixes.length;

	while ( i-- ) {
		name = cssPrefixes[ i ] + capName;
		if ( name in style ) {
			return name;
		}
	}

	return origName;
}

function isHidden( elem, el ) {
	// isHidden might be called from jQuery#filter function;
	// in that case, element will be second argument
	elem = el || elem;
	return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem );
}

function showHide( elements, show ) {
	var elem,
		values = [],
		index = 0,
		length = elements.length;

	for ( ; index < length; index++ ) {
		elem = elements[ index ];
		if ( !elem.style ) {
			continue;
		}
		values[ index ] = jQuery._data( elem, "olddisplay" );
		if ( show ) {
			// Reset the inline display of this element to learn if it is
			// being hidden by cascaded rules or not
			if ( !values[ index ] && elem.style.display === "none" ) {
				elem.style.display = "";
			}

			// Set elements which have been overridden with display: none
			// in a stylesheet to whatever the default browser style is
			// for such an element
			if ( elem.style.display === "" && isHidden( elem ) ) {
				values[ index ] = jQuery._data( elem, "olddisplay", css_defaultDisplay(elem.nodeName) );
			}
		} else if ( !values[ index ] && !isHidden( elem ) ) {
			jQuery._data( elem, "olddisplay", jQuery.css( elem, "display" ) );
		}
	}

	// Set the display of most of the elements in a second loop
	// to avoid the constant reflow
	for ( index = 0; index < length; index++ ) {
		elem = elements[ index ];
		if ( !elem.style ) {
			continue;
		}
		if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
			elem.style.display = show ? values[ index ] || "" : "none";
		}
	}

	return elements;
}

jQuery.fn.extend({
	css: function( name, value ) {
		return jQuery.access( this, function( elem, name, value ) {
			var styles, len,
				map = {},
				i = 0;

			if ( jQuery.isArray( name ) ) {
				styles = getStyles( elem );
				len = name.length;

				for ( ; i < len; i++ ) {
					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
				}

				return map;
			}

			return value !== undefined ?
				jQuery.style( elem, name, value ) :
				jQuery.css( elem, name );
		}, name, value, arguments.length > 1 );
	},
	show: function() {
		return showHide( this, true );
	},
	hide: function() {
		return showHide( this );
	},
	toggle: function( state ) {
		var bool = typeof state === "boolean";

		return this.each(function() {
			if ( bool ? state : isHidden( this ) ) {
				jQuery( this ).show();
			} else {
				jQuery( this ).hide();
			}
		});
	}
});

jQuery.extend({
	// Add in style property hooks for overriding the default
	// behavior of getting and setting a style property
	cssHooks: {
		opacity: {
			get: function( elem, computed ) {
				if ( computed ) {
					// We should always get a number back from opacity
					var ret = curCSS( elem, "opacity" );
					return ret === "" ? "1" : ret;
				}
			}
		}
	},

	// Exclude the following css properties to add px
	cssNumber: {
		"columnCount": true,
		"fillOpacity": true,
		"fontWeight": true,
		"lineHeight": true,
		"opacity": true,
		"orphans": true,
		"widows": true,
		"zIndex": true,
		"zoom": true
	},

	// Add in properties whose names you wish to fix before
	// setting or getting the value
	cssProps: {
		// normalize float css property
		"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
	},

	// Get and set the style property on a DOM Node
	style: function( elem, name, value, extra ) {
		// Don't set styles on text and comment nodes
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
			return;
		}

		// Make sure that we're working with the right name
		var ret, type, hooks,
			origName = jQuery.camelCase( name ),
			style = elem.style;

		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );

		// gets hook for the prefixed version
		// followed by the unprefixed version
		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

		// Check if we're setting a value
		if ( value !== undefined ) {
			type = typeof value;

			// convert relative number strings (+= or -=) to relative numbers. #7345
			if ( type === "string" && (ret = rrelNum.exec( value )) ) {
				value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
				// Fixes bug #9237
				type = "number";
			}

			// Make sure that NaN and null values aren't set. See: #7116
			if ( value == null || type === "number" && isNaN( value ) ) {
				return;
			}

			// If a number was passed in, add 'px' to the (except for certain CSS properties)
			if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
				value += "px";
			}

			// Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
			// but it would mean to define eight (for every problematic property) identical functions
			if ( !jQuery.support.clearCloneStyle && value === "" && name.indexOf("background") === 0 ) {
				style[ name ] = "inherit";
			}

			// If a hook was provided, use that value, otherwise just set the specified value
			if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) {

				// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
				// Fixes bug #5509
				try {
					style[ name ] = value;
				} catch(e) {}
			}

		} else {
			// If a hook was provided get the non-computed value from there
			if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
				return ret;
			}

			// Otherwise just get the value from the style object
			return style[ name ];
		}
	},

	css: function( elem, name, extra, styles ) {
		var val, num, hooks,
			origName = jQuery.camelCase( name );

		// Make sure that we're working with the right name
		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );

		// gets hook for the prefixed version
		// followed by the unprefixed version
		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

		// If a hook was provided get the computed value from there
		if ( hooks && "get" in hooks ) {
			val = hooks.get( elem, true, extra );
		}

		// Otherwise, if a way to get the computed value exists, use that
		if ( val === undefined ) {
			val = curCSS( elem, name, styles );
		}

		//convert "normal" to computed value
		if ( val === "normal" && name in cssNormalTransform ) {
			val = cssNormalTransform[ name ];
		}

		// Return, converting to number if forced or a qualifier was provided and val looks numeric
		if ( extra ) {
			num = parseFloat( val );
			return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;
		}
		return val;
	},

	// A method for quickly swapping in/out CSS properties to get correct calculations
	swap: function( elem, options, callback, args ) {
		var ret, name,
			old = {};

		// Remember the old values, and insert the new ones
		for ( name in options ) {
			old[ name ] = elem.style[ name ];
			elem.style[ name ] = options[ name ];
		}

		ret = callback.apply( elem, args || [] );

		// Revert the old values
		for ( name in options ) {
			elem.style[ name ] = old[ name ];
		}

		return ret;
	}
});

// NOTE: we've included the "window" in window.getComputedStyle
// because jsdom on node.js will break without it.
if ( window.getComputedStyle ) {
	getStyles = function( elem ) {
		return window.getComputedStyle( elem, null );
	};

	curCSS = function( elem, name, _computed ) {
		var width, minWidth, maxWidth,
			computed = _computed || getStyles( elem ),

			// getPropertyValue is only needed for .css('filter') in IE9, see #12537
			ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined,
			style = elem.style;

		if ( computed ) {

			if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
				ret = jQuery.style( elem, name );
			}

			// A tribute to the "awesome hack by Dean Edwards"
			// Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right
			// Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
			// this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
			if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) {

				// Remember the original values
				width = style.width;
				minWidth = style.minWidth;
				maxWidth = style.maxWidth;

				// Put in the new values to get a computed value out
				style.minWidth = style.maxWidth = style.width = ret;
				ret = computed.width;

				// Revert the changed values
				style.width = width;
				style.minWidth = minWidth;
				style.maxWidth = maxWidth;
			}
		}

		return ret;
	};
} else if ( document.documentElement.currentStyle ) {
	getStyles = function( elem ) {
		return elem.currentStyle;
	};

	curCSS = function( elem, name, _computed ) {
		var left, rs, rsLeft,
			computed = _computed || getStyles( elem ),
			ret = computed ? computed[ name ] : undefined,
			style = elem.style;

		// Avoid setting ret to empty string here
		// so we don't default to auto
		if ( ret == null && style && style[ name ] ) {
			ret = style[ name ];
		}

		// From the awesome hack by Dean Edwards
		// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291

		// If we're not dealing with a regular pixel number
		// but a number that has a weird ending, we need to convert it to pixels
		// but not position css attributes, as those are proportional to the parent element instead
		// and we can't measure the parent instead because it might trigger a "stacking dolls" problem
		if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {

			// Remember the original values
			left = style.left;
			rs = elem.runtimeStyle;
			rsLeft = rs && rs.left;

			// Put in the new values to get a computed value out
			if ( rsLeft ) {
				rs.left = elem.currentStyle.left;
			}
			style.left = name === "fontSize" ? "1em" : ret;
			ret = style.pixelLeft + "px";

			// Revert the changed values
			style.left = left;
			if ( rsLeft ) {
				rs.left = rsLeft;
			}
		}

		return ret === "" ? "auto" : ret;
	};
}

function setPositiveNumber( elem, value, subtract ) {
	var matches = rnumsplit.exec( value );
	return matches ?
		// Guard against undefined "subtract", e.g., when used as in cssHooks
		Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
		value;
}

function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
	var i = extra === ( isBorderBox ? "border" : "content" ) ?
		// If we already have the right measurement, avoid augmentation
		4 :
		// Otherwise initialize for horizontal or vertical properties
		name === "width" ? 1 : 0,

		val = 0;

	for ( ; i < 4; i += 2 ) {
		// both box models exclude margin, so add it if we want it
		if ( extra === "margin" ) {
			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
		}

		if ( isBorderBox ) {
			// border-box includes padding, so remove it if we want content
			if ( extra === "content" ) {
				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
			}

			// at this point, extra isn't border nor margin, so remove border
			if ( extra !== "margin" ) {
				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
			}
		} else {
			// at this point, extra isn't content, so add padding
			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );

			// at this point, extra isn't content nor padding, so add border
			if ( extra !== "padding" ) {
				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
			}
		}
	}

	return val;
}

function getWidthOrHeight( elem, name, extra ) {

	// Start with offset property, which is equivalent to the border-box value
	var valueIsBorderBox = true,
		val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
		styles = getStyles( elem ),
		isBorderBox = jQuery.support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box";

	// some non-html elements return undefined for offsetWidth, so check for null/undefined
	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
	if ( val <= 0 || val == null ) {
		// Fall back to computed then uncomputed css if necessary
		val = curCSS( elem, name, styles );
		if ( val < 0 || val == null ) {
			val = elem.style[ name ];
		}

		// Computed unit is not pixels. Stop here and return.
		if ( rnumnonpx.test(val) ) {
			return val;
		}

		// we need the check for style in case a browser which returns unreliable values
		// for getComputedStyle silently falls back to the reliable elem.style
		valueIsBorderBox = isBorderBox && ( jQuery.support.boxSizingReliable || val === elem.style[ name ] );

		// Normalize "", auto, and prepare for extra
		val = parseFloat( val ) || 0;
	}

	// use the active box-sizing model to add/subtract irrelevant styles
	return ( val +
		augmentWidthOrHeight(
			elem,
			name,
			extra || ( isBorderBox ? "border" : "content" ),
			valueIsBorderBox,
			styles
		)
	) + "px";
}

// Try to determine the default display value of an element
function css_defaultDisplay( nodeName ) {
	var doc = document,
		display = elemdisplay[ nodeName ];

	if ( !display ) {
		display = actualDisplay( nodeName, doc );

		// If the simple way fails, read from inside an iframe
		if ( display === "none" || !display ) {
			// Use the already-created iframe if possible
			iframe = ( iframe ||
				jQuery("<iframe frameborder='0' width='0' height='0'/>")
				.css( "cssText", "display:block !important" )
			).appendTo( doc.documentElement );

			// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
			doc = ( iframe[0].contentWindow || iframe[0].contentDocument ).document;
			doc.write("<!doctype html><html><body>");
			doc.close();

			display = actualDisplay( nodeName, doc );
			iframe.detach();
		}

		// Store the correct default display
		elemdisplay[ nodeName ] = display;
	}

	return display;
}

// Called ONLY from within css_defaultDisplay
function actualDisplay( name, doc ) {
	var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
		display = jQuery.css( elem[0], "display" );
	elem.remove();
	return display;
}

jQuery.each([ "height", "width" ], function( i, name ) {
	jQuery.cssHooks[ name ] = {
		get: function( elem, computed, extra ) {
			if ( computed ) {
				// certain elements can have dimension info if we invisibly show them
				// however, it must have a current display style that would benefit from this
				return elem.offsetWidth === 0 && rdisplayswap.test( jQuery.css( elem, "display" ) ) ?
					jQuery.swap( elem, cssShow, function() {
						return getWidthOrHeight( elem, name, extra );
					}) :
					getWidthOrHeight( elem, name, extra );
			}
		},

		set: function( elem, value, extra ) {
			var styles = extra && getStyles( elem );
			return setPositiveNumber( elem, value, extra ?
				augmentWidthOrHeight(
					elem,
					name,
					extra,
					jQuery.support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
					styles
				) : 0
			);
		}
	};
});

if ( !jQuery.support.opacity ) {
	jQuery.cssHooks.opacity = {
		get: function( elem, computed ) {
			// IE uses filters for opacity
			return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
				( 0.01 * parseFloat( RegExp.$1 ) ) + "" :
				computed ? "1" : "";
		},

		set: function( elem, value ) {
			var style = elem.style,
				currentStyle = elem.currentStyle,
				opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
				filter = currentStyle && currentStyle.filter || style.filter || "";

			// IE has trouble with opacity if it does not have layout
			// Force it by setting the zoom level
			style.zoom = 1;

			// if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
			// if value === "", then remove inline opacity #12685
			if ( ( value >= 1 || value === "" ) &&
					jQuery.trim( filter.replace( ralpha, "" ) ) === "" &&
					style.removeAttribute ) {

				// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
				// if "filter:" is present at all, clearType is disabled, we want to avoid this
				// style.removeAttribute is IE Only, but so apparently is this code path...
				style.removeAttribute( "filter" );

				// if there is no filter style applied in a css rule or unset inline opacity, we are done
				if ( value === "" || currentStyle && !currentStyle.filter ) {
					return;
				}
			}

			// otherwise, set new filter values
			style.filter = ralpha.test( filter ) ?
				filter.replace( ralpha, opacity ) :
				filter + " " + opacity;
		}
	};
}

// These hooks cannot be added until DOM ready because the support test
// for it is not run until after DOM ready
jQuery(function() {
	if ( !jQuery.support.reliableMarginRight ) {
		jQuery.cssHooks.marginRight = {
			get: function( elem, computed ) {
				if ( computed ) {
					// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
					// Work around by temporarily setting element display to inline-block
					return jQuery.swap( elem, { "display": "inline-block" },
						curCSS, [ elem, "marginRight" ] );
				}
			}
		};
	}

	// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
	// getComputedStyle returns percent when specified for top/left/bottom/right
	// rather than make the css module depend on the offset module, we just check for it here
	if ( !jQuery.support.pixelPosition && jQuery.fn.position ) {
		jQuery.each( [ "top", "left" ], function( i, prop ) {
			jQuery.cssHooks[ prop ] = {
				get: function( elem, computed ) {
					if ( computed ) {
						computed = curCSS( elem, prop );
						// if curCSS returns percentage, fallback to offset
						return rnumnonpx.test( computed ) ?
							jQuery( elem ).position()[ prop ] + "px" :
							computed;
					}
				}
			};
		});
	}

});

if ( jQuery.expr && jQuery.expr.filters ) {
	jQuery.expr.filters.hidden = function( elem ) {
		return ( elem.offsetWidth === 0 && elem.offsetHeight === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
	};

	jQuery.expr.filters.visible = function( elem ) {
		return !jQuery.expr.filters.hidden( elem );
	};
}

// These hooks are used by animate to expand properties
jQuery.each({
	margin: "",
	padding: "",
	border: "Width"
}, function( prefix, suffix ) {
	jQuery.cssHooks[ prefix + suffix ] = {
		expand: function( value ) {
			var i = 0,
				expanded = {},

				// assumes a single number if not a string
				parts = typeof value === "string" ? value.split(" ") : [ value ];

			for ( ; i < 4; i++ ) {
				expanded[ prefix + cssExpand[ i ] + suffix ] =
					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
			}

			return expanded;
		}
	};

	if ( !rmargin.test( prefix ) ) {
		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
	}
});
var r20 = /%20/g,
	rbracket = /\[\]$/,
	rCRLF = /\r?\n/g,
	rsubmitterTypes = /^(?:submit|button|image|reset)$/i,
	rsubmittable = /^(?:input|select|textarea|keygen)/i;

jQuery.fn.extend({
	serialize: function() {
		return jQuery.param( this.serializeArray() );
	},
	serializeArray: function() {
		return this.map(function(){
			// Can add propHook for "elements" to filter or add form elements
			var elements = jQuery.prop( this, "elements" );
			return elements ? jQuery.makeArray( elements ) : this;
		})
		.filter(function(){
			var type = this.type;
			// Use .is(":disabled") so that fieldset[disabled] works
			return this.name && !jQuery( this ).is( ":disabled" ) &&
				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
				( this.checked || !manipulation_rcheckableType.test( type ) );
		})
		.map(function( i, elem ){
			var val = jQuery( this ).val();

			return val == null ?
				null :
				jQuery.isArray( val ) ?
					jQuery.map( val, function( val ){
						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
					}) :
					{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
		}).get();
	}
});

//Serialize an array of form elements or a set of
//key/values into a query string
jQuery.param = function( a, traditional ) {
	var prefix,
		s = [],
		add = function( key, value ) {
			// If value is a function, invoke it and return its value
			value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value );
			s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
		};

	// Set traditional to true for jQuery <= 1.3.2 behavior.
	if ( traditional === undefined ) {
		traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
	}

	// If an array was passed in, assume that it is an array of form elements.
	if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
		// Serialize the form elements
		jQuery.each( a, function() {
			add( this.name, this.value );
		});

	} else {
		// If traditional, encode the "old" way (the way 1.3.2 or older
		// did it), otherwise encode params recursively.
		for ( prefix in a ) {
			buildParams( prefix, a[ prefix ], traditional, add );
		}
	}

	// Return the resulting serialization
	return s.join( "&" ).replace( r20, "+" );
};

function buildParams( prefix, obj, traditional, add ) {
	var name;

	if ( jQuery.isArray( obj ) ) {
		// Serialize array item.
		jQuery.each( obj, function( i, v ) {
			if ( traditional || rbracket.test( prefix ) ) {
				// Treat each array item as a scalar.
				add( prefix, v );

			} else {
				// Item is non-scalar (array or object), encode its numeric index.
				buildParams( prefix + "[" + ( typeof v === "object" ? i : "" ) + "]", v, traditional, add );
			}
		});

	} else if ( !traditional && jQuery.type( obj ) === "object" ) {
		// Serialize object item.
		for ( name in obj ) {
			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
		}

	} else {
		// Serialize scalar item.
		add( prefix, obj );
	}
}
var
	// Document location
	ajaxLocParts,
	ajaxLocation,
	
	ajax_nonce = jQuery.now(),

	ajax_rquery = /\?/,
	rhash = /#.*$/,
	rts = /([?&])_=[^&]*/,
	rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
	// #7653, #8125, #8152: local protocol detection
	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
	rnoContent = /^(?:GET|HEAD)$/,
	rprotocol = /^\/\//,
	rurl = /^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,

	// Keep a copy of the old load method
	_load = jQuery.fn.load,

	/* Prefilters
	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
	 * 2) These are called:
	 *    - BEFORE asking for a transport
	 *    - AFTER param serialization (s.data is a string if s.processData is true)
	 * 3) key is the dataType
	 * 4) the catchall symbol "*" can be used
	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
	 */
	prefilters = {},

	/* Transports bindings
	 * 1) key is the dataType
	 * 2) the catchall symbol "*" can be used
	 * 3) selection will start with transport dataType and THEN go to "*" if needed
	 */
	transports = {},

	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
	allTypes = "*/".concat("*");

// #8138, IE may throw an exception when accessing
// a field from window.location if document.domain has been set
try {
	ajaxLocation = location.href;
} catch( e ) {
	// Use the href attribute of an A element
	// since IE will modify it given document.location
	ajaxLocation = document.createElement( "a" );
	ajaxLocation.href = "";
	ajaxLocation = ajaxLocation.href;
}

// Segment location into parts
ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];

// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
function addToPrefiltersOrTransports( structure ) {

	// dataTypeExpression is optional and defaults to "*"
	return function( dataTypeExpression, func ) {

		if ( typeof dataTypeExpression !== "string" ) {
			func = dataTypeExpression;
			dataTypeExpression = "*";
		}

		var dataType,
			i = 0,
			dataTypes = dataTypeExpression.toLowerCase().match( core_rnotwhite ) || [];

		if ( jQuery.isFunction( func ) ) {
			// For each dataType in the dataTypeExpression
			while ( (dataType = dataTypes[i++]) ) {
				// Prepend if requested
				if ( dataType[0] === "+" ) {
					dataType = dataType.slice( 1 ) || "*";
					(structure[ dataType ] = structure[ dataType ] || []).unshift( func );

				// Otherwise append
				} else {
					(structure[ dataType ] = structure[ dataType ] || []).push( func );
				}
			}
		}
	};
}

// Base inspection function for prefilters and transports
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {

	var inspected = {},
		seekingTransport = ( structure === transports );

	function inspect( dataType ) {
		var selected;
		inspected[ dataType ] = true;
		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
			if( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
				options.dataTypes.unshift( dataTypeOrTransport );
				inspect( dataTypeOrTransport );
				return false;
			} else if ( seekingTransport ) {
				return !( selected = dataTypeOrTransport );
			}
		});
		return selected;
	}

	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
}

// A special extend for ajax options
// that takes "flat" options (not to be deep extended)
// Fixes #9887
function ajaxExtend( target, src ) {
	var key, deep,
		flatOptions = jQuery.ajaxSettings.flatOptions || {};

	for ( key in src ) {
		if ( src[ key ] !== undefined ) {
			( flatOptions[ key ] ? target : ( deep || (deep = {}) ) )[ key ] = src[ key ];
		}
	}
	if ( deep ) {
		jQuery.extend( true, target, deep );
	}

	return target;
}

jQuery.fn.load = function( url, params, callback ) {
	if ( typeof url !== "string" && _load ) {
		return _load.apply( this, arguments );
	}

	var selector, type, response,
		self = this,
		off = url.indexOf(" ");

	if ( off >= 0 ) {
		selector = url.slice( off, url.length );
		url = url.slice( 0, off );
	}

	// If it's a function
	if ( jQuery.isFunction( params ) ) {

		// We assume that it's the callback
		callback = params;
		params = undefined;

	// Otherwise, build a param string
	} else if ( params && typeof params === "object" ) {
		type = "POST";
	}

	// If we have elements to modify, make the request
	if ( self.length > 0 ) {
		jQuery.ajax({
			url: url,

			// if "type" variable is undefined, then "GET" method will be used
			type: type,
			dataType: "html",
			data: params
		}).done(function( responseText ) {

			// Save response for use in complete callback
			response = arguments;

			self.html( selector ?

				// If a selector was specified, locate the right elements in a dummy div
				// Exclude scripts to avoid IE 'Permission Denied' errors
				jQuery("<div>").append( jQuery.parseHTML( responseText ) ).find( selector ) :

				// Otherwise use the full result
				responseText );

		}).complete( callback && function( jqXHR, status ) {
			self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
		});
	}

	return this;
};

// Attach a bunch of functions for handling common AJAX events
jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ){
	jQuery.fn[ type ] = function( fn ){
		return this.on( type, fn );
	};
});

jQuery.each( [ "get", "post" ], function( i, method ) {
	jQuery[ method ] = function( url, data, callback, type ) {
		// shift arguments if data argument was omitted
		if ( jQuery.isFunction( data ) ) {
			type = type || callback;
			callback = data;
			data = undefined;
		}

		return jQuery.ajax({
			url: url,
			type: method,
			dataType: type,
			data: data,
			success: callback
		});
	};
});

jQuery.extend({

	// Counter for holding the number of active queries
	active: 0,

	// Last-Modified header cache for next request
	lastModified: {},
	etag: {},

	ajaxSettings: {
		url: ajaxLocation,
		type: "GET",
		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
		global: true,
		processData: true,
		async: true,
		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
		/*
		timeout: 0,
		data: null,
		dataType: null,
		username: null,
		password: null,
		cache: null,
		throws: false,
		traditional: false,
		headers: {},
		*/

		accepts: {
			"*": allTypes,
			text: "text/plain",
			html: "text/html",
			xml: "application/xml, text/xml",
			json: "application/json, text/javascript"
		},

		contents: {
			xml: /xml/,
			html: /html/,
			json: /json/
		},

		responseFields: {
			xml: "responseXML",
			text: "responseText"
		},

		// Data converters
		// Keys separate source (or catchall "*") and destination types with a single space
		converters: {

			// Convert anything to text
			"* text": window.String,

			// Text to html (true = no transformation)
			"text html": true,

			// Evaluate text as a json expression
			"text json": jQuery.parseJSON,

			// Parse text as xml
			"text xml": jQuery.parseXML
		},

		// For options that shouldn't be deep extended:
		// you can add your own custom options here if
		// and when you create one that shouldn't be
		// deep extended (see ajaxExtend)
		flatOptions: {
			url: true,
			context: true
		}
	},

	// Creates a full fledged settings object into target
	// with both ajaxSettings and settings fields.
	// If target is omitted, writes into ajaxSettings.
	ajaxSetup: function( target, settings ) {
		return settings ?

			// Building a settings object
			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :

			// Extending ajaxSettings
			ajaxExtend( jQuery.ajaxSettings, target );
	},

	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
	ajaxTransport: addToPrefiltersOrTransports( transports ),

	// Main method
	ajax: function( url, options ) {

		// If url is an object, simulate pre-1.5 signature
		if ( typeof url === "object" ) {
			options = url;
			url = undefined;
		}

		// Force options to be an object
		options = options || {};

		var transport,
			// URL without anti-cache param
			cacheURL,
			// Response headers
			responseHeadersString,
			responseHeaders,
			// timeout handle
			timeoutTimer,
			// Cross-domain detection vars
			parts,
			// To know if global events are to be dispatched
			fireGlobals,
			// Loop variable
			i,
			// Create the final options object
			s = jQuery.ajaxSetup( {}, options ),
			// Callbacks context
			callbackContext = s.context || s,
			// Context for global events is callbackContext if it is a DOM node or jQuery collection
			globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ?
				jQuery( callbackContext ) :
				jQuery.event,
			// Deferreds
			deferred = jQuery.Deferred(),
			completeDeferred = jQuery.Callbacks("once memory"),
			// Status-dependent callbacks
			statusCode = s.statusCode || {},
			// Headers (they are sent all at once)
			requestHeaders = {},
			requestHeadersNames = {},
			// The jqXHR state
			state = 0,
			// Default abort message
			strAbort = "canceled",
			// Fake xhr
			jqXHR = {
				readyState: 0,

				// Builds headers hashtable if needed
				getResponseHeader: function( key ) {
					var match;
					if ( state === 2 ) {
						if ( !responseHeaders ) {
							responseHeaders = {};
							while ( (match = rheaders.exec( responseHeadersString )) ) {
								responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
							}
						}
						match = responseHeaders[ key.toLowerCase() ];
					}
					return match == null ? null : match;
				},

				// Raw string
				getAllResponseHeaders: function() {
					return state === 2 ? responseHeadersString : null;
				},

				// Caches the header
				setRequestHeader: function( name, value ) {
					var lname = name.toLowerCase();
					if ( !state ) {
						name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
						requestHeaders[ name ] = value;
					}
					return this;
				},

				// Overrides response content-type header
				overrideMimeType: function( type ) {
					if ( !state ) {
						s.mimeType = type;
					}
					return this;
				},

				// Status-dependent callbacks
				statusCode: function( map ) {
					var code;
					if ( map ) {
						if ( state < 2 ) {
							for ( code in map ) {
								// Lazy-add the new callback in a way that preserves old ones
								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
							}
						} else {
							// Execute the appropriate callbacks
							jqXHR.always( map[ jqXHR.status ] );
						}
					}
					return this;
				},

				// Cancel the request
				abort: function( statusText ) {
					var finalText = statusText || strAbort;
					if ( transport ) {
						transport.abort( finalText );
					}
					done( 0, finalText );
					return this;
				}
			};

		// Attach deferreds
		deferred.promise( jqXHR ).complete = completeDeferred.add;
		jqXHR.success = jqXHR.done;
		jqXHR.error = jqXHR.fail;

		// Remove hash character (#7531: and string promotion)
		// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
		// Handle falsy url in the settings object (#10093: consistency with old signature)
		// We also use the url parameter if available
		s.url = ( ( url || s.url || ajaxLocation ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );

		// Alias method option to type as per ticket #12004
		s.type = options.method || options.type || s.method || s.type;

		// Extract dataTypes list
		s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( core_rnotwhite ) || [""];

		// A cross-domain request is in order when we have a protocol:host:port mismatch
		if ( s.crossDomain == null ) {
			parts = rurl.exec( s.url.toLowerCase() );
			s.crossDomain = !!( parts &&
				( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
					( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
						( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
			);
		}

		// Convert data if not already a string
		if ( s.data && s.processData && typeof s.data !== "string" ) {
			s.data = jQuery.param( s.data, s.traditional );
		}

		// Apply prefilters
		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );

		// If request was aborted inside a prefilter, stop there
		if ( state === 2 ) {
			return jqXHR;
		}

		// We can fire global events as of now if asked to
		fireGlobals = s.global;

		// Watch for a new set of requests
		if ( fireGlobals && jQuery.active++ === 0 ) {
			jQuery.event.trigger("ajaxStart");
		}

		// Uppercase the type
		s.type = s.type.toUpperCase();

		// Determine if request has content
		s.hasContent = !rnoContent.test( s.type );

		// Save the URL in case we're toying with the If-Modified-Since
		// and/or If-None-Match header later on
		cacheURL = s.url;

		// More options handling for requests with no content
		if ( !s.hasContent ) {

			// If data is available, append data to url
			if ( s.data ) {
				cacheURL = ( s.url += ( ajax_rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
				// #9682: remove data so that it's not used in an eventual retry
				delete s.data;
			}

			// Add anti-cache in url if needed
			if ( s.cache === false ) {
				s.url = rts.test( cacheURL ) ?

					// If there is already a '_' parameter, set its value
					cacheURL.replace( rts, "$1_=" + ajax_nonce++ ) :

					// Otherwise add one to the end
					cacheURL + ( ajax_rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ajax_nonce++;
			}
		}

		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
		if ( s.ifModified ) {
			if ( jQuery.lastModified[ cacheURL ] ) {
				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
			}
			if ( jQuery.etag[ cacheURL ] ) {
				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
			}
		}

		// Set the correct header, if data is being sent
		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
			jqXHR.setRequestHeader( "Content-Type", s.contentType );
		}

		// Set the Accepts header for the server, depending on the dataType
		jqXHR.setRequestHeader(
			"Accept",
			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
				s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
				s.accepts[ "*" ]
		);

		// Check for headers option
		for ( i in s.headers ) {
			jqXHR.setRequestHeader( i, s.headers[ i ] );
		}

		// Allow custom headers/mimetypes and early abort
		if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
			// Abort if not done already and return
			return jqXHR.abort();
		}

		// aborting is no longer a cancellation
		strAbort = "abort";

		// Install callbacks on deferreds
		for ( i in { success: 1, error: 1, complete: 1 } ) {
			jqXHR[ i ]( s[ i ] );
		}

		// Get transport
		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );

		// If no transport, we auto-abort
		if ( !transport ) {
			done( -1, "No Transport" );
		} else {
			jqXHR.readyState = 1;

			// Send global event
			if ( fireGlobals ) {
				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
			}
			// Timeout
			if ( s.async && s.timeout > 0 ) {
				timeoutTimer = setTimeout(function() {
					jqXHR.abort("timeout");
				}, s.timeout );
			}

			try {
				state = 1;
				transport.send( requestHeaders, done );
			} catch ( e ) {
				// Propagate exception as error if not done
				if ( state < 2 ) {
					done( -1, e );
				// Simply rethrow otherwise
				} else {
					throw e;
				}
			}
		}

		// Callback for when everything is done
		function done( status, nativeStatusText, responses, headers ) {
			var isSuccess, success, error, response, modified,
				statusText = nativeStatusText;

			// Called once
			if ( state === 2 ) {
				return;
			}

			// State is "done" now
			state = 2;

			// Clear timeout if it exists
			if ( timeoutTimer ) {
				clearTimeout( timeoutTimer );
			}

			// Dereference transport for early garbage collection
			// (no matter how long the jqXHR object will be used)
			transport = undefined;

			// Cache response headers
			responseHeadersString = headers || "";

			// Set readyState
			jqXHR.readyState = status > 0 ? 4 : 0;

			// Get response data
			if ( responses ) {
				response = ajaxHandleResponses( s, jqXHR, responses );
			}

			// If successful, handle type chaining
			if ( status >= 200 && status < 300 || status === 304 ) {

				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
				if ( s.ifModified ) {
					modified = jqXHR.getResponseHeader("Last-Modified");
					if ( modified ) {
						jQuery.lastModified[ cacheURL ] = modified;
					}
					modified = jqXHR.getResponseHeader("etag");
					if ( modified ) {
						jQuery.etag[ cacheURL ] = modified;
					}
				}

				// If not modified
				if ( status === 304 ) {
					isSuccess = true;
					statusText = "notmodified";

				// If we have data
				} else {
					isSuccess = ajaxConvert( s, response );
					statusText = isSuccess.state;
					success = isSuccess.data;
					error = isSuccess.error;
					isSuccess = !error;
				}
			} else {
				// We extract error from statusText
				// then normalize statusText and status for non-aborts
				error = statusText;
				if ( status || !statusText ) {
					statusText = "error";
					if ( status < 0 ) {
						status = 0;
					}
				}
			}

			// Set data for the fake xhr object
			jqXHR.status = status;
			jqXHR.statusText = ( nativeStatusText || statusText ) + "";

			// Success/Error
			if ( isSuccess ) {
				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
			} else {
				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
			}

			// Status-dependent callbacks
			jqXHR.statusCode( statusCode );
			statusCode = undefined;

			if ( fireGlobals ) {
				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
					[ jqXHR, s, isSuccess ? success : error ] );
			}

			// Complete
			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );

			if ( fireGlobals ) {
				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
				// Handle the global AJAX counter
				if ( !( --jQuery.active ) ) {
					jQuery.event.trigger("ajaxStop");
				}
			}
		}

		return jqXHR;
	},

	getScript: function( url, callback ) {
		return jQuery.get( url, undefined, callback, "script" );
	},

	getJSON: function( url, data, callback ) {
		return jQuery.get( url, data, callback, "json" );
	}
});

/* Handles responses to an ajax request:
 * - sets all responseXXX fields accordingly
 * - finds the right dataType (mediates between content-type and expected dataType)
 * - returns the corresponding response
 */
function ajaxHandleResponses( s, jqXHR, responses ) {

	var ct, type, finalDataType, firstDataType,
		contents = s.contents,
		dataTypes = s.dataTypes,
		responseFields = s.responseFields;

	// Fill responseXXX fields
	for ( type in responseFields ) {
		if ( type in responses ) {
			jqXHR[ responseFields[type] ] = responses[ type ];
		}
	}

	// Remove auto dataType and get content-type in the process
	while( dataTypes[ 0 ] === "*" ) {
		dataTypes.shift();
		if ( ct === undefined ) {
			ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
		}
	}

	// Check if we're dealing with a known content-type
	if ( ct ) {
		for ( type in contents ) {
			if ( contents[ type ] && contents[ type ].test( ct ) ) {
				dataTypes.unshift( type );
				break;
			}
		}
	}

	// Check to see if we have a response for the expected dataType
	if ( dataTypes[ 0 ] in responses ) {
		finalDataType = dataTypes[ 0 ];
	} else {
		// Try convertible dataTypes
		for ( type in responses ) {
			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
				finalDataType = type;
				break;
			}
			if ( !firstDataType ) {
				firstDataType = type;
			}
		}
		// Or just use first one
		finalDataType = finalDataType || firstDataType;
	}

	// If we found a dataType
	// We add the dataType to the list if needed
	// and return the corresponding response
	if ( finalDataType ) {
		if ( finalDataType !== dataTypes[ 0 ] ) {
			dataTypes.unshift( finalDataType );
		}
		return responses[ finalDataType ];
	}
}

// Chain conversions given the request and the original response
function ajaxConvert( s, response ) {

	var conv, conv2, current, tmp,
		converters = {},
		i = 0,
		// Work with a copy of dataTypes in case we need to modify it for conversion
		dataTypes = s.dataTypes.slice(),
		prev = dataTypes[ 0 ];

	// Apply the dataFilter if provided
	if ( s.dataFilter ) {
		response = s.dataFilter( response, s.dataType );
	}

	// Create converters map with lowercased keys
	if ( dataTypes[ 1 ] ) {
		for ( conv in s.converters ) {
			converters[ conv.toLowerCase() ] = s.converters[ conv ];
		}
	}

	// Convert to each sequential dataType, tolerating list modification
	for ( ; (current = dataTypes[++i]); ) {

		// There's only work to do if current dataType is non-auto
		if ( current !== "*" ) {

			// Convert response if prev dataType is non-auto and differs from current
			if ( prev !== "*" && prev !== current ) {

				// Seek a direct converter
				conv = converters[ prev + " " + current ] || converters[ "* " + current ];

				// If none found, seek a pair
				if ( !conv ) {
					for ( conv2 in converters ) {

						// If conv2 outputs current
						tmp = conv2.split(" ");
						if ( tmp[ 1 ] === current ) {

							// If prev can be converted to accepted input
							conv = converters[ prev + " " + tmp[ 0 ] ] ||
								converters[ "* " + tmp[ 0 ] ];
							if ( conv ) {
								// Condense equivalence converters
								if ( conv === true ) {
									conv = converters[ conv2 ];

								// Otherwise, insert the intermediate dataType
								} else if ( converters[ conv2 ] !== true ) {
									current = tmp[ 0 ];
									dataTypes.splice( i--, 0, current );
								}

								break;
							}
						}
					}
				}

				// Apply converter (if not an equivalence)
				if ( conv !== true ) {

					// Unless errors are allowed to bubble, catch and return them
					if ( conv && s["throws"] ) {
						response = conv( response );
					} else {
						try {
							response = conv( response );
						} catch ( e ) {
							return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
						}
					}
				}
			}

			// Update prev for next iteration
			prev = current;
		}
	}

	return { state: "success", data: response };
}
// Install script dataType
jQuery.ajaxSetup({
	accepts: {
		script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
	},
	contents: {
		script: /(?:java|ecma)script/
	},
	converters: {
		"text script": function( text ) {
			jQuery.globalEval( text );
			return text;
		}
	}
});

// Handle cache's special case and global
jQuery.ajaxPrefilter( "script", function( s ) {
	if ( s.cache === undefined ) {
		s.cache = false;
	}
	if ( s.crossDomain ) {
		s.type = "GET";
		s.global = false;
	}
});

// Bind script tag hack transport
jQuery.ajaxTransport( "script", function(s) {

	// This transport only deals with cross domain requests
	if ( s.crossDomain ) {

		var script,
			head = document.head || jQuery("head")[0] || document.documentElement;

		return {

			send: function( _, callback ) {

				script = document.createElement("script");

				script.async = true;

				if ( s.scriptCharset ) {
					script.charset = s.scriptCharset;
				}

				script.src = s.url;

				// Attach handlers for all browsers
				script.onload = script.onreadystatechange = function( _, isAbort ) {

					if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {

						// Handle memory leak in IE
						script.onload = script.onreadystatechange = null;

						// Remove the script
						if ( script.parentNode ) {
							script.parentNode.removeChild( script );
						}

						// Dereference the script
						script = null;

						// Callback if not abort
						if ( !isAbort ) {
							callback( 200, "success" );
						}
					}
				};

				// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
				// Use native DOM manipulation to avoid our domManip AJAX trickery
				head.insertBefore( script, head.firstChild );
			},

			abort: function() {
				if ( script ) {
					script.onload( undefined, true );
				}
			}
		};
	}
});
var oldCallbacks = [],
	rjsonp = /(=)\?(?=&|$)|\?\?/;

// Default jsonp settings
jQuery.ajaxSetup({
	jsonp: "callback",
	jsonpCallback: function() {
		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( ajax_nonce++ ) );
		this[ callback ] = true;
		return callback;
	}
});

// Detect, normalize options and install callbacks for jsonp requests
jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {

	var callbackName, overwritten, responseContainer,
		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
			"url" :
			typeof s.data === "string" && !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") && rjsonp.test( s.data ) && "data"
		);

	// Handle iff the expected data type is "jsonp" or we have a parameter to set
	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {

		// Get callback name, remembering preexisting value associated with it
		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
			s.jsonpCallback() :
			s.jsonpCallback;

		// Insert callback into url or form data
		if ( jsonProp ) {
			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
		} else if ( s.jsonp !== false ) {
			s.url += ( ajax_rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
		}

		// Use data converter to retrieve json after script execution
		s.converters["script json"] = function() {
			if ( !responseContainer ) {
				jQuery.error( callbackName + " was not called" );
			}
			return responseContainer[ 0 ];
		};

		// force json dataType
		s.dataTypes[ 0 ] = "json";

		// Install callback
		overwritten = window[ callbackName ];
		window[ callbackName ] = function() {
			responseContainer = arguments;
		};

		// Clean-up function (fires after converters)
		jqXHR.always(function() {
			// Restore preexisting value
			window[ callbackName ] = overwritten;

			// Save back as free
			if ( s[ callbackName ] ) {
				// make sure that re-using the options doesn't screw things around
				s.jsonpCallback = originalSettings.jsonpCallback;

				// save the callback name for future use
				oldCallbacks.push( callbackName );
			}

			// Call if it was a function and we have a response
			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
				overwritten( responseContainer[ 0 ] );
			}

			responseContainer = overwritten = undefined;
		});

		// Delegate to script
		return "script";
	}
});
var xhrCallbacks, xhrSupported,
	xhrId = 0,
	// #5280: Internet Explorer will keep connections alive if we don't abort on unload
	xhrOnUnloadAbort = window.ActiveXObject && function() {
		// Abort all pending requests
		var key;
		for ( key in xhrCallbacks ) {
			xhrCallbacks[ key ]( undefined, true );
		}
	};

// Functions to create xhrs
function createStandardXHR() {
	try {
		return new window.XMLHttpRequest();
	} catch( e ) {}
}

function createActiveXHR() {
	try {
		return new window.ActiveXObject("Microsoft.XMLHTTP");
	} catch( e ) {}
}

// Create the request object
// (This is still attached to ajaxSettings for backward compatibility)
jQuery.ajaxSettings.xhr = window.ActiveXObject ?
	/* Microsoft failed to properly
	 * implement the XMLHttpRequest in IE7 (can't request local files),
	 * so we use the ActiveXObject when it is available
	 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
	 * we need a fallback.
	 */
	function() {
		return !this.isLocal && createStandardXHR() || createActiveXHR();
	} :
	// For all other browsers, use the standard XMLHttpRequest object
	createStandardXHR;

// Determine support properties
xhrSupported = jQuery.ajaxSettings.xhr();
jQuery.support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
xhrSupported = jQuery.support.ajax = !!xhrSupported;

// Create transport if the browser can provide an xhr
if ( xhrSupported ) {

	jQuery.ajaxTransport(function( s ) {
		// Cross domain only allowed if supported through XMLHttpRequest
		if ( !s.crossDomain || jQuery.support.cors ) {

			var callback;

			return {
				send: function( headers, complete ) {

					// Get a new xhr
					var handle, i,
						xhr = s.xhr();

					// Open the socket
					// Passing null username, generates a login popup on Opera (#2865)
					if ( s.username ) {
						xhr.open( s.type, s.url, s.async, s.username, s.password );
					} else {
						xhr.open( s.type, s.url, s.async );
					}

					// Apply custom fields if provided
					if ( s.xhrFields ) {
						for ( i in s.xhrFields ) {
							xhr[ i ] = s.xhrFields[ i ];
						}
					}

					// Override mime type if needed
					if ( s.mimeType && xhr.overrideMimeType ) {
						xhr.overrideMimeType( s.mimeType );
					}

					// X-Requested-With header
					// For cross-domain requests, seeing as conditions for a preflight are
					// akin to a jigsaw puzzle, we simply never set it to be sure.
					// (it can always be set on a per-request basis or even using ajaxSetup)
					// For same-domain requests, won't change header if already provided.
					if ( !s.crossDomain && !headers["X-Requested-With"] ) {
						headers["X-Requested-With"] = "XMLHttpRequest";
					}

					// Need an extra try/catch for cross domain requests in Firefox 3
					try {
						for ( i in headers ) {
							xhr.setRequestHeader( i, headers[ i ] );
						}
					} catch( err ) {}

					// Do send the request
					// This may raise an exception which is actually
					// handled in jQuery.ajax (so no try/catch here)
					xhr.send( ( s.hasContent && s.data ) || null );

					// Listener
					callback = function( _, isAbort ) {

						var status,
							statusText,
							responseHeaders,
							responses,
							xml;

						// Firefox throws exceptions when accessing properties
						// of an xhr when a network error occurred
						// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
						try {

							// Was never called and is aborted or complete
							if ( callback && ( isAbort || xhr.readyState === 4 ) ) {

								// Only called once
								callback = undefined;

								// Do not keep as active anymore
								if ( handle ) {
									xhr.onreadystatechange = jQuery.noop;
									if ( xhrOnUnloadAbort ) {
										delete xhrCallbacks[ handle ];
									}
								}

								// If it's an abort
								if ( isAbort ) {
									// Abort it manually if needed
									if ( xhr.readyState !== 4 ) {
										xhr.abort();
									}
								} else {
									responses = {};
									status = xhr.status;
									xml = xhr.responseXML;
									responseHeaders = xhr.getAllResponseHeaders();

									// Construct response list
									if ( xml && xml.documentElement /* #4958 */ ) {
										responses.xml = xml;
									}

									// When requesting binary data, IE6-9 will throw an exception
									// on any attempt to access responseText (#11426)
									if ( typeof xhr.responseText === "string" ) {
										responses.text = xhr.responseText;
									}

									// Firefox throws an exception when accessing
									// statusText for faulty cross-domain requests
									try {
										statusText = xhr.statusText;
									} catch( e ) {
										// We normalize with Webkit giving an empty statusText
										statusText = "";
									}

									// Filter status for non standard behaviors

									// If the request is local and we have data: assume a success
									// (success with no data won't get notified, that's the best we
									// can do given current implementations)
									if ( !status && s.isLocal && !s.crossDomain ) {
										status = responses.text ? 200 : 404;
									// IE - #1450: sometimes returns 1223 when it should be 204
									} else if ( status === 1223 ) {
										status = 204;
									}
								}
							}
						} catch( firefoxAccessException ) {
							if ( !isAbort ) {
								complete( -1, firefoxAccessException );
							}
						}

						// Call complete if needed
						if ( responses ) {
							complete( status, statusText, responses, responseHeaders );
						}
					};

					if ( !s.async ) {
						// if we're in sync mode we fire the callback
						callback();
					} else if ( xhr.readyState === 4 ) {
						// (IE6 & IE7) if it's in cache and has been
						// retrieved directly we need to fire the callback
						setTimeout( callback );
					} else {
						handle = ++xhrId;
						if ( xhrOnUnloadAbort ) {
							// Create the active xhrs callbacks list if needed
							// and attach the unload handler
							if ( !xhrCallbacks ) {
								xhrCallbacks = {};
								jQuery( window ).unload( xhrOnUnloadAbort );
							}
							// Add to list of active xhrs callbacks
							xhrCallbacks[ handle ] = callback;
						}
						xhr.onreadystatechange = callback;
					}
				},

				abort: function() {
					if ( callback ) {
						callback( undefined, true );
					}
				}
			};
		}
	});
}
var fxNow, timerId,
	rfxtypes = /^(?:toggle|show|hide)$/,
	rfxnum = new RegExp( "^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$", "i" ),
	rrun = /queueHooks$/,
	animationPrefilters = [ defaultPrefilter ],
	tweeners = {
		"*": [function( prop, value ) {
			var end, unit,
				tween = this.createTween( prop, value ),
				parts = rfxnum.exec( value ),
				target = tween.cur(),
				start = +target || 0,
				scale = 1,
				maxIterations = 20;

			if ( parts ) {
				end = +parts[2];
				unit = parts[3] || ( jQuery.cssNumber[ prop ] ? "" : "px" );

				// We need to compute starting value
				if ( unit !== "px" && start ) {
					// Iteratively approximate from a nonzero starting point
					// Prefer the current property, because this process will be trivial if it uses the same units
					// Fallback to end or a simple constant
					start = jQuery.css( tween.elem, prop, true ) || end || 1;

					do {
						// If previous iteration zeroed out, double until we get *something*
						// Use a string for doubling factor so we don't accidentally see scale as unchanged below
						scale = scale || ".5";

						// Adjust and apply
						start = start / scale;
						jQuery.style( tween.elem, prop, start + unit );

					// Update scale, tolerating zero or NaN from tween.cur()
					// And breaking the loop if scale is unchanged or perfect, or if we've just had enough
					} while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
				}

				tween.unit = unit;
				tween.start = start;
				// If a +=/-= token was provided, we're doing a relative animation
				tween.end = parts[1] ? start + ( parts[1] + 1 ) * end : end;
			}
			return tween;
		}]
	};

// Animations created synchronously will run synchronously
function createFxNow() {
	setTimeout(function() {
		fxNow = undefined;
	});
	return ( fxNow = jQuery.now() );
}

function createTweens( animation, props ) {
	jQuery.each( props, function( prop, value ) {
		var collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
			index = 0,
			length = collection.length;
		for ( ; index < length; index++ ) {
			if ( collection[ index ].call( animation, prop, value ) ) {

				// we're done with this property
				return;
			}
		}
	});
}

function Animation( elem, properties, options ) {
	var result,
		stopped,
		index = 0,
		length = animationPrefilters.length,
		deferred = jQuery.Deferred().always( function() {
			// don't match elem in the :animated selector
			delete tick.elem;
		}),
		tick = function() {
			if ( stopped ) {
				return false;
			}
			var currentTime = fxNow || createFxNow(),
				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
				// archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)
				temp = remaining / animation.duration || 0,
				percent = 1 - temp,
				index = 0,
				length = animation.tweens.length;

			for ( ; index < length ; index++ ) {
				animation.tweens[ index ].run( percent );
			}

			deferred.notifyWith( elem, [ animation, percent, remaining ]);

			if ( percent < 1 && length ) {
				return remaining;
			} else {
				deferred.resolveWith( elem, [ animation ] );
				return false;
			}
		},
		animation = deferred.promise({
			elem: elem,
			props: jQuery.extend( {}, properties ),
			opts: jQuery.extend( true, { specialEasing: {} }, options ),
			originalProperties: properties,
			originalOptions: options,
			startTime: fxNow || createFxNow(),
			duration: options.duration,
			tweens: [],
			createTween: function( prop, end ) {
				var tween = jQuery.Tween( elem, animation.opts, prop, end,
						animation.opts.specialEasing[ prop ] || animation.opts.easing );
				animation.tweens.push( tween );
				return tween;
			},
			stop: function( gotoEnd ) {
				var index = 0,
					// if we are going to the end, we want to run all the tweens
					// otherwise we skip this part
					length = gotoEnd ? animation.tweens.length : 0;
				if ( stopped ) {
					return this;
				}
				stopped = true;
				for ( ; index < length ; index++ ) {
					animation.tweens[ index ].run( 1 );
				}

				// resolve when we played the last frame
				// otherwise, reject
				if ( gotoEnd ) {
					deferred.resolveWith( elem, [ animation, gotoEnd ] );
				} else {
					deferred.rejectWith( elem, [ animation, gotoEnd ] );
				}
				return this;
			}
		}),
		props = animation.props;

	propFilter( props, animation.opts.specialEasing );

	for ( ; index < length ; index++ ) {
		result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
		if ( result ) {
			return result;
		}
	}

	createTweens( animation, props );

	if ( jQuery.isFunction( animation.opts.start ) ) {
		animation.opts.start.call( elem, animation );
	}

	jQuery.fx.timer(
		jQuery.extend( tick, {
			elem: elem,
			anim: animation,
			queue: animation.opts.queue
		})
	);

	// attach callbacks from options
	return animation.progress( animation.opts.progress )
		.done( animation.opts.done, animation.opts.complete )
		.fail( animation.opts.fail )
		.always( animation.opts.always );
}

function propFilter( props, specialEasing ) {
	var index, name, easing, value, hooks;

	// camelCase, specialEasing and expand cssHook pass
	for ( index in props ) {
		name = jQuery.camelCase( index );
		easing = specialEasing[ name ];
		value = props[ index ];
		if ( jQuery.isArray( value ) ) {
			easing = value[ 1 ];
			value = props[ index ] = value[ 0 ];
		}

		if ( index !== name ) {
			props[ name ] = value;
			delete props[ index ];
		}

		hooks = jQuery.cssHooks[ name ];
		if ( hooks && "expand" in hooks ) {
			value = hooks.expand( value );
			delete props[ name ];

			// not quite $.extend, this wont overwrite keys already present.
			// also - reusing 'index' from above because we have the correct "name"
			for ( index in value ) {
				if ( !( index in props ) ) {
					props[ index ] = value[ index ];
					specialEasing[ index ] = easing;
				}
			}
		} else {
			specialEasing[ name ] = easing;
		}
	}
}

jQuery.Animation = jQuery.extend( Animation, {

	tweener: function( props, callback ) {
		if ( jQuery.isFunction( props ) ) {
			callback = props;
			props = [ "*" ];
		} else {
			props = props.split(" ");
		}

		var prop,
			index = 0,
			length = props.length;

		for ( ; index < length ; index++ ) {
			prop = props[ index ];
			tweeners[ prop ] = tweeners[ prop ] || [];
			tweeners[ prop ].unshift( callback );
		}
	},

	prefilter: function( callback, prepend ) {
		if ( prepend ) {
			animationPrefilters.unshift( callback );
		} else {
			animationPrefilters.push( callback );
		}
	}
});

function defaultPrefilter( elem, props, opts ) {
	/*jshint validthis:true */
	var index, prop, value, length, dataShow, toggle, tween, hooks, oldfire,
		anim = this,
		style = elem.style,
		orig = {},
		handled = [],
		hidden = elem.nodeType && isHidden( elem );

	// handle queue: false promises
	if ( !opts.queue ) {
		hooks = jQuery._queueHooks( elem, "fx" );
		if ( hooks.unqueued == null ) {
			hooks.unqueued = 0;
			oldfire = hooks.empty.fire;
			hooks.empty.fire = function() {
				if ( !hooks.unqueued ) {
					oldfire();
				}
			};
		}
		hooks.unqueued++;

		anim.always(function() {
			// doing this makes sure that the complete handler will be called
			// before this completes
			anim.always(function() {
				hooks.unqueued--;
				if ( !jQuery.queue( elem, "fx" ).length ) {
					hooks.empty.fire();
				}
			});
		});
	}

	// height/width overflow pass
	if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
		// Make sure that nothing sneaks out
		// Record all 3 overflow attributes because IE does not
		// change the overflow attribute when overflowX and
		// overflowY are set to the same value
		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];

		// Set display property to inline-block for height/width
		// animations on inline elements that are having width/height animated
		if ( jQuery.css( elem, "display" ) === "inline" &&
				jQuery.css( elem, "float" ) === "none" ) {

			// inline-level elements accept inline-block;
			// block-level elements need to be inline with layout
			if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) {
				style.display = "inline-block";

			} else {
				style.zoom = 1;
			}
		}
	}

	if ( opts.overflow ) {
		style.overflow = "hidden";
		if ( !jQuery.support.shrinkWrapBlocks ) {
			anim.done(function() {
				style.overflow = opts.overflow[ 0 ];
				style.overflowX = opts.overflow[ 1 ];
				style.overflowY = opts.overflow[ 2 ];
			});
		}
	}


	// show/hide pass
	for ( index in props ) {
		value = props[ index ];
		if ( rfxtypes.exec( value ) ) {
			delete props[ index ];
			toggle = toggle || value === "toggle";
			if ( value === ( hidden ? "hide" : "show" ) ) {
				continue;
			}
			handled.push( index );
		}
	}

	length = handled.length;
	if ( length ) {
		dataShow = jQuery._data( elem, "fxshow" ) || jQuery._data( elem, "fxshow", {} );
		if ( "hidden" in dataShow ) {
			hidden = dataShow.hidden;
		}

		// store state if its toggle - enables .stop().toggle() to "reverse"
		if ( toggle ) {
			dataShow.hidden = !hidden;
		}
		if ( hidden ) {
			jQuery( elem ).show();
		} else {
			anim.done(function() {
				jQuery( elem ).hide();
			});
		}
		anim.done(function() {
			var prop;
			jQuery._removeData( elem, "fxshow" );
			for ( prop in orig ) {
				jQuery.style( elem, prop, orig[ prop ] );
			}
		});
		for ( index = 0 ; index < length ; index++ ) {
			prop = handled[ index ];
			tween = anim.createTween( prop, hidden ? dataShow[ prop ] : 0 );
			orig[ prop ] = dataShow[ prop ] || jQuery.style( elem, prop );

			if ( !( prop in dataShow ) ) {
				dataShow[ prop ] = tween.start;
				if ( hidden ) {
					tween.end = tween.start;
					tween.start = prop === "width" || prop === "height" ? 1 : 0;
				}
			}
		}
	}
}

function Tween( elem, options, prop, end, easing ) {
	return new Tween.prototype.init( elem, options, prop, end, easing );
}
jQuery.Tween = Tween;

Tween.prototype = {
	constructor: Tween,
	init: function( elem, options, prop, end, easing, unit ) {
		this.elem = elem;
		this.prop = prop;
		this.easing = easing || "swing";
		this.options = options;
		this.start = this.now = this.cur();
		this.end = end;
		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
	},
	cur: function() {
		var hooks = Tween.propHooks[ this.prop ];

		return hooks && hooks.get ?
			hooks.get( this ) :
			Tween.propHooks._default.get( this );
	},
	run: function( percent ) {
		var eased,
			hooks = Tween.propHooks[ this.prop ];

		if ( this.options.duration ) {
			this.pos = eased = jQuery.easing[ this.easing ](
				percent, this.options.duration * percent, 0, 1, this.options.duration
			);
		} else {
			this.pos = eased = percent;
		}
		this.now = ( this.end - this.start ) * eased + this.start;

		if ( this.options.step ) {
			this.options.step.call( this.elem, this.now, this );
		}

		if ( hooks && hooks.set ) {
			hooks.set( this );
		} else {
			Tween.propHooks._default.set( this );
		}
		return this;
	}
};

Tween.prototype.init.prototype = Tween.prototype;

Tween.propHooks = {
	_default: {
		get: function( tween ) {
			var result;

			if ( tween.elem[ tween.prop ] != null &&
				(!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
				return tween.elem[ tween.prop ];
			}

			// passing a non empty string as a 3rd parameter to .css will automatically
			// attempt a parseFloat and fallback to a string if the parse fails
			// so, simple values such as "10px" are parsed to Float.
			// complex values such as "rotate(1rad)" are returned as is.
			result = jQuery.css( tween.elem, tween.prop, "auto" );
			// Empty strings, null, undefined and "auto" are converted to 0.
			return !result || result === "auto" ? 0 : result;
		},
		set: function( tween ) {
			// use step hook for back compat - use cssHook if its there - use .style if its
			// available and use plain properties where available
			if ( jQuery.fx.step[ tween.prop ] ) {
				jQuery.fx.step[ tween.prop ]( tween );
			} else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
			} else {
				tween.elem[ tween.prop ] = tween.now;
			}
		}
	}
};

// Remove in 2.0 - this supports IE8's panic based approach
// to setting things on disconnected nodes

Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
	set: function( tween ) {
		if ( tween.elem.nodeType && tween.elem.parentNode ) {
			tween.elem[ tween.prop ] = tween.now;
		}
	}
};

jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
	var cssFn = jQuery.fn[ name ];
	jQuery.fn[ name ] = function( speed, easing, callback ) {
		return speed == null || typeof speed === "boolean" ?
			cssFn.apply( this, arguments ) :
			this.animate( genFx( name, true ), speed, easing, callback );
	};
});

jQuery.fn.extend({
	fadeTo: function( speed, to, easing, callback ) {

		// show any hidden elements after setting opacity to 0
		return this.filter( isHidden ).css( "opacity", 0 ).show()

			// animate to the value specified
			.end().animate({ opacity: to }, speed, easing, callback );
	},
	animate: function( prop, speed, easing, callback ) {
		var empty = jQuery.isEmptyObject( prop ),
			optall = jQuery.speed( speed, easing, callback ),
			doAnimation = function() {
				// Operate on a copy of prop so per-property easing won't be lost
				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
				doAnimation.finish = function() {
					anim.stop( true );
				};
				// Empty animations, or finishing resolves immediately
				if ( empty || jQuery._data( this, "finish" ) ) {
					anim.stop( true );
				}
			};
			doAnimation.finish = doAnimation;

		return empty || optall.queue === false ?
			this.each( doAnimation ) :
			this.queue( optall.queue, doAnimation );
	},
	stop: function( type, clearQueue, gotoEnd ) {
		var stopQueue = function( hooks ) {
			var stop = hooks.stop;
			delete hooks.stop;
			stop( gotoEnd );
		};

		if ( typeof type !== "string" ) {
			gotoEnd = clearQueue;
			clearQueue = type;
			type = undefined;
		}
		if ( clearQueue && type !== false ) {
			this.queue( type || "fx", [] );
		}

		return this.each(function() {
			var dequeue = true,
				index = type != null && type + "queueHooks",
				timers = jQuery.timers,
				data = jQuery._data( this );

			if ( index ) {
				if ( data[ index ] && data[ index ].stop ) {
					stopQueue( data[ index ] );
				}
			} else {
				for ( index in data ) {
					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
						stopQueue( data[ index ] );
					}
				}
			}

			for ( index = timers.length; index--; ) {
				if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
					timers[ index ].anim.stop( gotoEnd );
					dequeue = false;
					timers.splice( index, 1 );
				}
			}

			// start the next in the queue if the last step wasn't forced
			// timers currently will call their complete callbacks, which will dequeue
			// but only if they were gotoEnd
			if ( dequeue || !gotoEnd ) {
				jQuery.dequeue( this, type );
			}
		});
	},
	finish: function( type ) {
		if ( type !== false ) {
			type = type || "fx";
		}
		return this.each(function() {
			var index,
				data = jQuery._data( this ),
				queue = data[ type + "queue" ],
				hooks = data[ type + "queueHooks" ],
				timers = jQuery.timers,
				length = queue ? queue.length : 0;

			// enable finishing flag on private data
			data.finish = true;

			// empty the queue first
			jQuery.queue( this, type, [] );

			if ( hooks && hooks.cur && hooks.cur.finish ) {
				hooks.cur.finish.call( this );
			}

			// look for any active animations, and finish them
			for ( index = timers.length; index--; ) {
				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
					timers[ index ].anim.stop( true );
					timers.splice( index, 1 );
				}
			}

			// look for any animations in the old queue and finish them
			for ( index = 0; index < length; index++ ) {
				if ( queue[ index ] && queue[ index ].finish ) {
					queue[ index ].finish.call( this );
				}
			}

			// turn off finishing flag
			delete data.finish;
		});
	}
});

// Generate parameters to create a standard animation
function genFx( type, includeWidth ) {
	var which,
		attrs = { height: type },
		i = 0;

	// if we include width, step value is 1 to do all cssExpand values,
	// if we don't include width, step value is 2 to skip over Left and Right
	includeWidth = includeWidth? 1 : 0;
	for( ; i < 4 ; i += 2 - includeWidth ) {
		which = cssExpand[ i ];
		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
	}

	if ( includeWidth ) {
		attrs.opacity = attrs.width = type;
	}

	return attrs;
}

// Generate shortcuts for custom animations
jQuery.each({
	slideDown: genFx("show"),
	slideUp: genFx("hide"),
	slideToggle: genFx("toggle"),
	fadeIn: { opacity: "show" },
	fadeOut: { opacity: "hide" },
	fadeToggle: { opacity: "toggle" }
}, function( name, props ) {
	jQuery.fn[ name ] = function( speed, easing, callback ) {
		return this.animate( props, speed, easing, callback );
	};
});

jQuery.speed = function( speed, easing, fn ) {
	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
		complete: fn || !fn && easing ||
			jQuery.isFunction( speed ) && speed,
		duration: speed,
		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
	};

	opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
		opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;

	// normalize opt.queue - true/undefined/null -> "fx"
	if ( opt.queue == null || opt.queue === true ) {
		opt.queue = "fx";
	}

	// Queueing
	opt.old = opt.complete;

	opt.complete = function() {
		if ( jQuery.isFunction( opt.old ) ) {
			opt.old.call( this );
		}

		if ( opt.queue ) {
			jQuery.dequeue( this, opt.queue );
		}
	};

	return opt;
};

jQuery.easing = {
	linear: function( p ) {
		return p;
	},
	swing: function( p ) {
		return 0.5 - Math.cos( p*Math.PI ) / 2;
	}
};

jQuery.timers = [];
jQuery.fx = Tween.prototype.init;
jQuery.fx.tick = function() {
	var timer,
		timers = jQuery.timers,
		i = 0;

	fxNow = jQuery.now();

	for ( ; i < timers.length; i++ ) {
		timer = timers[ i ];
		// Checks the timer has not already been removed
		if ( !timer() && timers[ i ] === timer ) {
			timers.splice( i--, 1 );
		}
	}

	if ( !timers.length ) {
		jQuery.fx.stop();
	}
	fxNow = undefined;
};

jQuery.fx.timer = function( timer ) {
	if ( timer() && jQuery.timers.push( timer ) ) {
		jQuery.fx.start();
	}
};

jQuery.fx.interval = 13;

jQuery.fx.start = function() {
	if ( !timerId ) {
		timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
	}
};

jQuery.fx.stop = function() {
	clearInterval( timerId );
	timerId = null;
};

jQuery.fx.speeds = {
	slow: 600,
	fast: 200,
	// Default speed
	_default: 400
};

// Back Compat <1.8 extension point
jQuery.fx.step = {};

if ( jQuery.expr && jQuery.expr.filters ) {
	jQuery.expr.filters.animated = function( elem ) {
		return jQuery.grep(jQuery.timers, function( fn ) {
			return elem === fn.elem;
		}).length;
	};
}
jQuery.fn.offset = function( options ) {
	if ( arguments.length ) {
		return options === undefined ?
			this :
			this.each(function( i ) {
				jQuery.offset.setOffset( this, options, i );
			});
	}

	var docElem, win,
		box = { top: 0, left: 0 },
		elem = this[ 0 ],
		doc = elem && elem.ownerDocument;

	if ( !doc ) {
		return;
	}

	docElem = doc.documentElement;

	// Make sure it's not a disconnected DOM node
	if ( !jQuery.contains( docElem, elem ) ) {
		return box;
	}

	// If we don't have gBCR, just use 0,0 rather than error
	// BlackBerry 5, iOS 3 (original iPhone)
	if ( typeof elem.getBoundingClientRect !== "undefined" ) {
		box = elem.getBoundingClientRect();
	}
	win = getWindow( doc );
	return {
		top: box.top  + ( win.pageYOffset || docElem.scrollTop )  - ( docElem.clientTop  || 0 ),
		left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )
	};
};

jQuery.offset = {

	setOffset: function( elem, options, i ) {
		var position = jQuery.css( elem, "position" );

		// set position first, in-case top/left are set even on static elem
		if ( position === "static" ) {
			elem.style.position = "relative";
		}

		var curElem = jQuery( elem ),
			curOffset = curElem.offset(),
			curCSSTop = jQuery.css( elem, "top" ),
			curCSSLeft = jQuery.css( elem, "left" ),
			calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
			props = {}, curPosition = {}, curTop, curLeft;

		// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
		if ( calculatePosition ) {
			curPosition = curElem.position();
			curTop = curPosition.top;
			curLeft = curPosition.left;
		} else {
			curTop = parseFloat( curCSSTop ) || 0;
			curLeft = parseFloat( curCSSLeft ) || 0;
		}

		if ( jQuery.isFunction( options ) ) {
			options = options.call( elem, i, curOffset );
		}

		if ( options.top != null ) {
			props.top = ( options.top - curOffset.top ) + curTop;
		}
		if ( options.left != null ) {
			props.left = ( options.left - curOffset.left ) + curLeft;
		}

		if ( "using" in options ) {
			options.using.call( elem, props );
		} else {
			curElem.css( props );
		}
	}
};


jQuery.fn.extend({

	position: function() {
		if ( !this[ 0 ] ) {
			return;
		}

		var offsetParent, offset,
			parentOffset = { top: 0, left: 0 },
			elem = this[ 0 ];

		// fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is it's only offset parent
		if ( jQuery.css( elem, "position" ) === "fixed" ) {
			// we assume that getBoundingClientRect is available when computed position is fixed
			offset = elem.getBoundingClientRect();
		} else {
			// Get *real* offsetParent
			offsetParent = this.offsetParent();

			// Get correct offsets
			offset = this.offset();
			if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
				parentOffset = offsetParent.offset();
			}

			// Add offsetParent borders
			parentOffset.top  += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true );
			parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true );
		}

		// Subtract parent offsets and element margins
		// note: when an element has margin: auto the offsetLeft and marginLeft
		// are the same in Safari causing offset.left to incorrectly be 0
		return {
			top:  offset.top  - parentOffset.top - jQuery.css( elem, "marginTop", true ),
			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true)
		};
	},

	offsetParent: function() {
		return this.map(function() {
			var offsetParent = this.offsetParent || document.documentElement;
			while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) && jQuery.css( offsetParent, "position") === "static" ) ) {
				offsetParent = offsetParent.offsetParent;
			}
			return offsetParent || document.documentElement;
		});
	}
});


// Create scrollLeft and scrollTop methods
jQuery.each( {scrollLeft: "pageXOffset", scrollTop: "pageYOffset"}, function( method, prop ) {
	var top = /Y/.test( prop );

	jQuery.fn[ method ] = function( val ) {
		return jQuery.access( this, function( elem, method, val ) {
			var win = getWindow( elem );

			if ( val === undefined ) {
				return win ? (prop in win) ? win[ prop ] :
					win.document.documentElement[ method ] :
					elem[ method ];
			}

			if ( win ) {
				win.scrollTo(
					!top ? val : jQuery( win ).scrollLeft(),
					top ? val : jQuery( win ).scrollTop()
				);

			} else {
				elem[ method ] = val;
			}
		}, method, val, arguments.length, null );
	};
});

function getWindow( elem ) {
	return jQuery.isWindow( elem ) ?
		elem :
		elem.nodeType === 9 ?
			elem.defaultView || elem.parentWindow :
			false;
}
// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
		// margin is only for outerHeight, outerWidth
		jQuery.fn[ funcName ] = function( margin, value ) {
			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );

			return jQuery.access( this, function( elem, type, value ) {
				var doc;

				if ( jQuery.isWindow( elem ) ) {
					// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
					// isn't a whole lot we can do. See pull request at this URL for discussion:
					// https://github.com/jquery/jquery/pull/764
					return elem.document.documentElement[ "client" + name ];
				}

				// Get document width or height
				if ( elem.nodeType === 9 ) {
					doc = elem.documentElement;

					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest
					// unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
					return Math.max(
						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
						elem.body[ "offset" + name ], doc[ "offset" + name ],
						doc[ "client" + name ]
					);
				}

				return value === undefined ?
					// Get width or height on the element, requesting but not forcing parseFloat
					jQuery.css( elem, type, extra ) :

					// Set width or height on the element
					jQuery.style( elem, type, value, extra );
			}, type, chainable ? margin : undefined, chainable, null );
		};
	});
});
// Limit scope pollution from any deprecated API
// (function() {

// })();
// Expose jQuery to the global object
window.jQuery = window.$ = jQuery;

// Expose jQuery as an AMD module, but only for AMD loaders that
// understand the issues with loading multiple versions of jQuery
// in a page that all might call define(). The loader will indicate
// they have special allowances for multiple jQuery versions by
// specifying define.amd.jQuery = true. Register as a named module,
// since jQuery can be concatenated with other files that may use define,
// but not use a proper concatenation script that understands anonymous
// AMD modules. A named AMD is safest and most robust way to register.
// Lowercase jquery is used because AMD module names are derived from
// file names, and jQuery is normally delivered in a lowercase file name.
// Do this after creating the global so that if an AMD module wants to call
// noConflict to hide this version of jQuery, it will work.
if ( typeof define === "function" && define.amd && define.amd.jQuery ) {
	define( "jquery", [], function () { return jQuery; } );
}

})( window );

================================================
FILE: vendors/baron/js/qwery.js
================================================
/*!
  * @preserve Qwery - A Blazing Fast query selector engine
  * https://github.com/ded/qwery
  * copyright Dustin Diaz 2012
  * MIT License
  */

(function (name, context, definition) {
  if (typeof module != 'undefined' && module.exports) module.exports = definition()
  else if (typeof define == 'function' && define.amd) define(definition)
  else context[name] = definition()
})('qwery', this, function () {
  var doc = document
    , html = doc.documentElement
    , byClass = 'getElementsByClassName'
    , byTag = 'getElementsByTagName'
    , qSA = 'querySelectorAll'
    , useNativeQSA = 'useNativeQSA'
    , tagName = 'tagName'
    , nodeType = 'nodeType'
    , select // main select() method, assign later

    , id = /#([\w\-]+)/
    , clas = /\.[\w\-]+/g
    , idOnly = /^#([\w\-]+)$/
    , classOnly = /^\.([\w\-]+)$/
    , tagOnly = /^([\w\-]+)$/
    , tagAndOrClass = /^([\w]+)?\.([\w\-]+)$/
    , splittable = /(^|,)\s*[>~+]/
    , normalizr = /^\s+|\s*([,\s\+\~>]|$)\s*/g
    , splitters = /[\s\>\+\~]/
    , splittersMore = /(?![\s\w\-\/\?\&\=\:\.\(\)\!,@#%<>\{\}\$\*\^'"]*\]|[\s\w\+\-]*\))/
    , specialChars = /([.*+?\^=!:${}()|\[\]\/\\])/g
    , simple = /^(\*|[a-z0-9]+)?(?:([\.\#]+[\w\-\.#]+)?)/
    , attr = /\[([\w\-]+)(?:([\|\^\$\*\~]?\=)['"]?([ \w\-\/\?\&\=\:\.\(\)\!,@#%<>\{\}\$\*\^]+)["']?)?\]/
    , pseudo = /:([\w\-]+)(\(['"]?([^()]+)['"]?\))?/
    , easy = new RegExp(idOnly.source + '|' + tagOnly.source + '|' + classOnly.source)
    , dividers = new RegExp('(' + splitters.source + ')' + splittersMore.source, 'g')
    , tokenizr = new RegExp(splitters.source + splittersMore.source)
    , chunker = new RegExp(simple.source + '(' + attr.source + ')?' + '(' + pseudo.source + ')?')

  var walker = {
      ' ': function (node) {
        return node && node !== html && node.parentNode
      }
    , '>': function (node, contestant) {
        return node && node.parentNode == contestant.parentNode && node.parentNode
      }
    , '~': function (node) {
        return node && node.previousSibling
      }
    , '+': function (node, contestant, p1, p2) {
        if (!node) return false
        return (p1 = previous(node)) && (p2 = previous(contestant)) && p1 == p2 && p1
      }
    }

  function cache() {
    this.c = {}
  }
  cache.prototype = {
    g: function (k) {
      return this.c[k] || undefined
    }
  , s: function (k, v, r) {
      v = r ? new RegExp(v) : v
      return (this.c[k] = v)
    }
  }

  var classCache = new cache()
    , cleanCache = new cache()
    , attrCache = new cache()
    , tokenCache = new cache()

  function classRegex(c) {
    return classCache.g(c) || classCache.s(c, '(^|\\s+)' + c + '(\\s+|$)', 1)
  }

  // not quite as fast as inline loops in older browsers so don't use liberally
  function each(a, fn) {
    var i = 0, l = a.length
    for (; i < l; i++) fn(a[i])
  }

  function flatten(ar) {
    for (var r = [], i = 0, l = ar.length; i < l; ++i) arrayLike(ar[i]) ? (r = r.concat(ar[i])) : (r[r.length] = ar[i])
    return r
  }

  function arrayify(ar) {
    var i = 0, l = ar.length, r = []
    for (; i < l; i++) r[i] = ar[i]
    return r
  }

  function previous(n) {
    while (n = n.previousSibling) if (n[nodeType] == 1) break;
    return n
  }

  function q(query) {
    return query.match(chunker)
  }

  // called using `this` as element and arguments from regex group results.
  // given => div.hello[title="world"]:foo('bar')
  // div.hello[title="world"]:foo('bar'), div, .hello, [title="world"], title, =, world, :foo('bar'), foo, ('bar'), bar]
  function interpret(whole, tag, idsAndClasses, wholeAttribute, attribute, qualifier, value, wholePseudo, pseudo, wholePseudoVal, pseudoVal) {
    var i, m, k, o, classes
    if (this[nodeType] !== 1) return false
    if (tag && tag !== '*' && this[tagName] && this[tagName].toLowerCase() !== tag) return false
    if (idsAndClasses && (m = idsAndClasses.match(id)) && m[1] !== this.id) return false
    if (idsAndClasses && (classes = idsAndClasses.match(clas))) {
      for (i = classes.length; i--;) if (!classRegex(classes[i].slice(1)).test(this.className)) return false
    }
    if (pseudo && qwery.pseudos[pseudo] && !qwery.pseudos[pseudo](this, pseudoVal)) return false
    if (wholeAttribute && !value) { // select is just for existance of attrib
      o = this.attributes
      for (k in o) {
        if (Object.prototype.hasOwnProperty.call(o, k) && (o[k].name || k) == attribute) {
          return this
        }
      }
    }
    if (wholeAttribute && !checkAttr(qualifier, getAttr(this, attribute) || '', value)) {
      // select is for attrib equality
      return false
    }
    return this
  }

  function clean(s) {
    return cleanCache.g(s) || cleanCache.s(s, s.replace(specialChars, '\\$1'))
  }

  function checkAttr(qualify, actual, val) {
    switch (qualify) {
    case '=':
      return actual == val
    case '^=':
      return actual.match(attrCache.g('^=' + val) || attrCache.s('^=' + val, '^' + clean(val), 1))
    case '$=':
      return actual.match(attrCache.g('$=' + val) || attrCache.s('$=' + val, clean(val) + '$', 1))
    case '*=':
      return actual.match(attrCache.g(val) || attrCache.s(val, clean(val), 1))
    case '~=':
      return actual.match(attrCache.g('~=' + val) || attrCache.s('~=' + val, '(?:^|\\s+)' + clean(val) + '(?:\\s+|$)', 1))
    case '|=':
      return actual.match(attrCache.g('|=' + val) || attrCache.s('|=' + val, '^' + clean(val) + '(-|$)', 1))
    }
    return 0
  }

  // given a selector, first check for simple cases then collect all base candidate matches and filter
  function _qwery(selector, _root) {
    var r = [], ret = [], i, l, m, token, tag, els, intr, item, root = _root
      , tokens = tokenCache.g(selector) || tokenCache.s(selector, selector.split(tokenizr))
      , dividedTokens = selector.match(dividers)

    if (!tokens.length) return r

    token = (tokens = tokens.slice(0)).pop() // copy cached tokens, take the last one
    if (tokens.length && (m = tokens[tokens.length - 1].match(idOnly))) root = byId(_root, m[1])
    if (!root) return r

    intr = q(token)
    // collect base candidates to filter
    els = root !== _root && root[nodeType] !== 9 && dividedTokens && /^[+~]$/.test(dividedTokens[dividedTokens.length - 1]) ?
      function (r) {
        while (root = root.nextSibling) {
          root[nodeType] == 1 && (intr[1] ? intr[1] == root[tagName].toLowerCase() : 1) && (r[r.length] = root)
        }
        return r
      }([]) :
      root[byTag](intr[1] || '*')
    // filter elements according to the right-most part of the selector
    for (i = 0, l = els.length; i < l; i++) {
      if (item = interpret.apply(els[i], intr)) r[r.length] = item
    }
    if (!tokens.length) return r

    // filter further according to the rest of the selector (the left side)
    each(r, function (e) { if (ancestorMatch(e, tokens, dividedTokens)) ret[ret.length] = e })
    return ret
  }

  // compare element to a selector
  function is(el, selector, root) {
    if (isNode(selector)) return el == selector
    if (arrayLike(selector)) return !!~flatten(selector).indexOf(el) // if selector is an array, is el a member?

    var selectors = selector.split(','), tokens, dividedTokens
    while (selector = selectors.pop()) {
      tokens = tokenCache.g(selector) || tokenCache.s(selector, selector.split(tokenizr))
      dividedTokens = selector.match(dividers)
      tokens = tokens.slice(0) // copy array
      if (interpret.apply(el, q(tokens.pop())) && (!tokens.length || ancestorMatch(el, tokens, dividedTokens, root))) {
        return true
      }
    }
    return false
  }

  // given elements matching the right-most part of a selector, filter out any that don't match the rest
  function ancestorMatch(el, tokens, dividedTokens, root) {
    var cand
    // recursively work backwards through the tokens and up the dom, covering all options
    function crawl(e, i, p) {
      while (p = walker[dividedTokens[i]](p, e)) {
        if (isNode(p) && (interpret.apply(p, q(tokens[i])))) {
          if (i) {
            if (cand = crawl(p, i - 1, p)) return cand
          } else return p
        }
      }
    }
    return (cand = crawl(el, tokens.length - 1, el)) && (!root || isAncestor(cand, root))
  }

  function isNode(el, t) {
    return el && typeof el === 'object' && (t = el[nodeType]) && (t == 1 || t == 9)
  }

  function uniq(ar) {
    var a = [], i, j;
    o:
    for (i = 0; i < ar.length; ++i) {
      for (j = 0; j < a.length; ++j) if (a[j] == ar[i]) continue o
      a[a.length] = ar[i]
    }
    return a
  }

  function arrayLike(o) {
    return (typeof o === 'object' && isFinite(o.length))
  }

  function normalizeRoot(root) {
    if (!root) return doc
    if (typeof root == 'string') return qwery(root)[0]
    if (!root[nodeType] && arrayLike(root)) return root[0]
    return root
  }

  function byId(root, id, el) {
    // if doc, query on it, else query the parent doc or if a detached fragment rewrite the query and run on the fragment
    return root[nodeType] === 9 ? root.getElementById(id) :
      root.ownerDocument &&
        (((el = root.ownerDocument.getElementById(id)) && isAncestor(el, root) && el) ||
          (!isAncestor(root, root.ownerDocument) && select('[id="' + id + '"]', root)[0]))
  }

  function qwery(selector, _root) {
    var m, el, root = normalizeRoot(_root)

    // easy, fast cases that we can dispatch with simple DOM calls
    if (!root || !selector) return []
    if (selector === window || isNode(selector)) {
      return !_root || (selector !== window && isNode(root) && isAncestor(selector, root)) ? [selector] : []
    }
    if (selector && arrayLike(selector)) return flatten(selector)
    if (m = selector.match(easy)) {
      if (m[1]) return (el = byId(root, m[1])) ? [el] : []
      if (m[2]) return arrayify(root[byTag](m[2]))
      if (hasByClass && m[3]) return arrayify(root[byClass](m[3]))
    }

    return select(selector, root)
  }

  // where the root is not document and a relationship selector is first we have to
  // do some awkward adjustments to get it to work, even with qSA
  function collectSelector(root, collector) {
    return function (s) {
      var oid, nid
      if (splittable.test(s)) {
        if (root[nodeType] !== 9) {
          // make sure the el has an id, rewrite the query, set root to doc and run it
          if (!(nid = oid = root.getAttribute('id'))) root.setAttribute('id', nid = '__qwerymeupscotty')
          s = '[id="' + nid + '"]' + s // avoid byId and allow us to match context element
          collector(root.parentNode || root, s, true)
          oid || root.removeAttribute('id')
        }
        return;
      }
      s.length && collector(root, s, false)
    }
  }

  var isAncestor = 'compareDocumentPosition' in html ?
    function (element, container) {
      return (container.compareDocumentPosition(element) & 16) == 16
    } : 'contains' in html ?
    function (element, container) {
      container = container[nodeType] === 9 || container == window ? html : container
      return container !== element && container.contains(element)
    } :
    function (element, container) {
      while (element = element.parentNode) if (element === container) return 1
      return 0
    }
  , getAttr = function () {
      // detect buggy IE src/href getAttribute() call
      var e = doc.createElement('p')
      return ((e.innerHTML = '<a href="#x">x</a>') && e.firstChild.getAttribute('href') != '#x') ?
        function (e, a) {
          return a === 'class' ? e.className : (a === 'href' || a === 'src') ?
            e.getAttribute(a, 2) : e.getAttribute(a)
        } :
        function (e, a) { return e.getAttribute(a) }
    }()
  , hasByClass = !!doc[byClass]
    // has native qSA support
  , hasQSA = doc.querySelector && doc[qSA]
    // use native qSA
  , selectQSA = function (selector, root) {
      var result = [], ss, e
      try {
        if (root[nodeType] === 9 || !splittable.test(selector)) {
          // most work is done right here, defer to qSA
          return arrayify(root[qSA](selector))
        }
        // special case where we need the services of `collectSelector()`
        each(ss = selector.split(','), collectSelector(root, function (ctx, s) {
          e = ctx[qSA](s)
          if (e.length == 1) result[result.length] = e.item(0)
          else if (e.length) result = result.concat(arrayify(e))
        }))
        return ss.length > 1 && result.length > 1 ? uniq(result) : result
      } catch (ex) { }
      return selectNonNative(selector, root)
    }
    // no native selector support
  , selectNonNative = function (selector, root) {
      var result = [], items, m, i, l, r, ss
      selector = selector.replace(normalizr, '$1')
      if (m = selector.match(tagAndOrClass)) {
        r = classRegex(m[2])
        items = root[byTag](m[1] || '*')
        for (i = 0, l = items.length; i < l; i++) {
          if (r.test(items[i].className)) result[result.length] = items[i]
        }
        return result
      }
      // more complex selector, get `_qwery()` to do the work for us
      each(ss = selector.split(','), collectSelector(root, function (ctx, s, rewrite) {
        r = _qwery(s, ctx)
        for (i = 0, l = r.length; i < l; i++) {
          if (ctx[nodeType] === 9 || rewrite || isAncestor(r[i], root)) result[result.length] = r[i]
        }
      }))
      return ss.length > 1 && result.length > 1 ? uniq(result) : result
    }
  , configure = function (options) {
      // configNativeQSA: use fully-internal selector or native qSA where present
      if (typeof options[useNativeQSA] !== 'undefined')
        select = !options[useNativeQSA] ? selectNonNative : hasQSA ? selectQSA : selectNonNative
    }

  configure({ useNativeQSA: true })

  qwery.configure = configure
  qwery.uniq = uniq
  qwery.is = is
  qwery.pseudos = {}

  return qwery
});

================================================
FILE: vendors/baron/package.json
================================================
{
    "name": "baron",
    "description": "A small, fast and crossbrowser custom scrollbar with native system scroll mechanic.",
    "version": "0.6.2",
    "homepage": "https://github.com/Diokuz/baron",
    "authors": [
        "Dmitry Kuznecov <@Diokuz>"
    ],
    "repository": {
        "type": "git",
        "url": "https://github.com/Diokuz/baron.git"
    },
    "keywords": [
        "scrollbar",
        "custom",
        "crossbrowser"
    ],
    "main": "./baron.js",
    "devDependencies": {
        "grunt": "~0.4.1",
        "grunt-contrib-jshint": "~0.6.0",
        "grunt-contrib-concat": "~0.1.3",
        "grunt-contrib-uglify": "~0.2.0",
        "mocha": "~1.9.0",
        "mocha-phantomjs": "~3.0.0",
        "grunt-mocha-phantomjs": "~0.3.0",
        "chai": "~1.7.0"
    }
}

================================================
FILE: vendors/baron/readme.md
================================================
Baron — a small, fast and crossbrowser custom scrollbar with native system scroll mechanic.

## Demo

http://diokuz.github.io/baron/

## Features

- Doesn't replace native system scroll mechanic.
- Customizable scrollbar design with full CSS support.
- No strong dependencies on jQuery.
- Plugin system (fixable headers, sticky footer, autotests and more)

Baron just hides the system scrollbar, without removing it. This guarantees scrolling will work on any system where the CSS property 'overflow: scroll' is applied.

## Simple usage

If you want only to hide system scrollbar:

* Include either the development or minified version of baron.js:

```js
<script src="baron.js"></script>
```

* Make some HTML:

```html
<div class="scroller">
    Your scrollable content here
</div>
```

* And some CSS:

```css
.scroller {
    overflow-y: scroll;
    /* -webkit-overflow-scrolling: touch; *//* uncomment to accelerate scrolling on iOS */
}
.scroller::-webkit-scrollbar { /* Prevents webkit cross-direction scrolling bug */
    width: 0;
}
```

Note: you can choose any class names, and style them as you want.

* Initialize baron:

```js
$('.scroller').baron();
```

## Advanced usage

```html
<div class="scroller">
    Your scrollable content here
    <div class="scroller__track"><!-- Track is optional -->
        <div class="scroller__bar"></div>
    </div>
</div>
```

```css
.scroller {
    overflow-y: scroll;
    /* -webkit-overflow-scrolling: touch; *//* uncomment to accelerate scrolling on iOS */
}
.scroller::-webkit-scrollbar { /* Preventing webkit cross-direction scrolling bug */
    width: 0;
}
.scroller__track {
    display: none; /* Invisible by default */
    position: absolute;
    right: 4px;
    top: 10px;
    bottom: 4px;
    width: 10px;
    background: rgba(0, 0, 0, .1);
}
.baron .scroller__track {
    display: block; /* Visible when scrolling is possible */
}
.scroller__bar { /* The bar. You should define width, right position and background */
    position: absolute;    
    z-index: 1;
    right: 0;
    width: 10px;
    background: #999;
}
```

You can specify some parameters on baron initialization:

```js
var scroll = $('.scroller').baron(params);

// or
var scroll = baron(params);
```

and store baron scrollbar object to `scroll` variable.

where:

```js
params = {
    // Selector for scroller element.
    // Default: this (in jQuery mode).
    scroller: '.scroller',

    // Root html element for baron. Use this param when your html-scrollbar content is outside scroller
    // Default: scroller
    root: $('.my_scroller'),

    // Selector for bar element
    // Default: 'undefined'
    bar: '.scroller__bar',

    // Track
    // Default: parent node of bar
    track: '.scroller__track',

    // CSS classname for scroller when its needed (when content height above scroller heights)
    // Default: ''
    barOnCls: 'baron',
    // Note: by default scroller__bar should be invisible

    // Scroll direction
    // Default: 'v' (vertical), 'h' for second baron invocation
    direction: 'h',

    // Freezing size of scroller parent, if true. Actual for horizontal scrolling.
    // Default: false
    freeze: true,

    // Minimum time delay between two scroll or resize events fires in seconds
    // Default: 0
    pause: .2,

    // Local copy of jQuery-like utility
    // Default: window.jQuery
    $: function(selector, context) {
        return bonzo(qwery(selector, context));
    },

    // Event manager
    // Default: function(elem, event, func, mode) { params.$(elem)[mode || 'on'](event, func); };
    event: function(elem, event, func, mode) { // Events manager
        if (mode == 'trigger') {
            mode = 'fire';
        }

        bean[mode || 'on'](elem, event, func);
    }
}
```

All parameters are optional (except scroller or root, if you are not using baron as jQuery plugin).

`scroll` methods:

```js
scroll.update(); // Update scroller
scroll.dispose(); // Remove baron instance and related event handlers
```

Note: baron returns the baron object, even in jQuery mode. That can break jQuery chaining. For example, you can't do this:

```js
$('.scroller').baron().css().animate();
```

but you can:

```js
$('.scroller').css().animate().baron();
```

and even more:

```js
var scroll = $('.scroller').css().animate().baron().fix();

scroll.baron({direction: 'h'}).test().anotherBaronPlugin();
```

Every baron plugin sould return baron object (this);

## Horizontal and bidirectional scroll

To switch default vertical direction to horizontal direction just set 'direction' param to 'h' value:

```js
baron({
    ...
    direction: 'h'
});
```

If you want to scroll in both directions (vertical and horizontal) you must initialize baron two times: one per direction. In than case you can do chaining:

```js
baron(vParams).baron(hParams);
```

Note: think about horizontal baron as about second independent baron instance, or as about plugin for 'baron', which simply calls 'baron' with redefined default params - both statements are true, actually. Unfortunately, in case above you only can manage last baron instance in chain (to update or dispose it). To manage both you have to initialize them independently:

```js
vScroll = baron(vParams);
hScroll = baron(hParams);
...
vScroll.dispose();
hScroll.dispose();
```

##Updating baron

When container size changed (for example: you load additional data to the container using ajax), you should call update() method:

```js
scroll.update();
```

or fire custom event 'sizeChange' to wrapper:

```js
$('.scroller').trigger('sizeChange');
```

##Disposing baron

If you removed html-nodes, which used baron, from DOM, dont forget dispose related baron instance manually. Use 'dispose' method for that.

##noConflict mode

If you need window.baron for another purposes you can restore original value:
```js
// window.baron points to some other library
...
// you include baron, it replaces the window.baron variable to baron namespace

var graf = baron.noConflict();
// now window.baron points to that other library again, and you can use window.graf() etc.
```

## Custom build (Grunt)

If you want exclude plugins functionality, type
```js
grunt core
```
in your console, and you will get dist/baron.js and dist/baron.min.js only with core functionality.

Type
```js
grunt full
```
to build full version of baron (including all available plugins).

Output files you can find in /dist/ folder.

## Browsers support

Full support: Chrome 1+, Firefox 3.6+, Safari 5+, Opera 9+ on Windows, OS X and iOS. Also, the best ever browser downloader - Internet Explorer - supported since version 7.

Partial (core) support: IE6.

Not supported: Opera mini, old versions of Android browser, and other browsers which does not implemented the `overflow: scroll` CSS property.

## fix plugin

To use fixable headers you should initialize fix plugin after baron:

```html
<div class="scroller">
    <div class="header__title-wrapper">
        <div class="header__title">First element</div>
    </div>
    ...content...
    <div class="header__title-wrapper">
        <div class="header__title">Second element</div>
    </div>
    ...content...
</div>
```

```js
baron(baronParams).fix(params);
```

where:
```js
params = {
    // CSS selector for fixable elements
    // Must have parentNode (no margin and padding allowed!) with same height (see demo for details). Also see 'limiter' parameter.
    elements: '.header__title',

    // CSS class for elements which now are outside of viewport
    outside: 'header__title_state_fixed',

    // CSS class for closest outsite element wrapper from top (left)
    before: 'header__title_position_top',

    // CSS class for closest outsite element wrapper from bottom (right)
    after: 'header__title_position_bottom',

    // if true - sets track top (left) position to header[0].parentNode.offsetHeight (offsetWidth)
    // Default: false
    limiter: true,

    // Radius for element fixing in px
    // Default: 0
    radius: 10,

    // Wether click on element should scroll to
    clickable: false,

    // User defined callback on click (data == {x1: current scrollTop, x2: new scrollTop})
    scroll: function(data) {}
}
```

## Controls plugin

```js
baron().controls(params);

params = {
    // Element to be used as interactive track. Note: it could be different from 'track' param of baron.
    track: '.visual-track',

    // Element to be used as 'down' / 'right' button
    forward: '.forward-btn',

    // Element to be used as 'up' / 'left' button
    backward: '.backward-btn',

    // Multiplyer for page-down action. Use 1 to scroll preciesly one screen per track click.
    // Default: .9
    screen: .5

    // Scroll distance per control button click in px
    // Default: 30
    delta: 40
}
```

## test plugin

If you have some troubles with baron, use test plugin:

```js
baron(...).test(params);
```

And read results in browser console.

There is no params for test() right now.

## License

MIT.


================================================
FILE: vendors/baron/src/controls.js
================================================
/* Controls plugin for baron 0.6+ */
(function(window, undefined) {
    var controls = function(params) {
        var forward, backward, track, screen,
            self = this; // AAAAAA!!!!!11

        screen = params.screen || 0.9;

        if (params.forward) {
            forward = this.$(params.forward, this.clipper);

            this.event(forward, 'click', function() {
                var y = self.pos() - params.delta || 30;
                
                self.pos(y);
            });
        }

        if (params.backward) {
            backward = this.$(params.backward, this.clipper);

            this.event(backward, 'click', function() {
                var y = self.pos() + params.delta || 30;

                self.pos(y);
            });
        }

        if (params.track) {
            if (params.track === true) {
                track = this.track;
            } else {
                track = this.$(params.track, this.clipper)[0];
            }

            if (track) {
                this.event(track, 'mousedown', function(e) {
                    var x = e['offset' + self.origin.x],
                        xBar = self.bar[self.origin.offsetPos],
                        sign = 0;

                    if (x < xBar) {
                        sign = -1;
                    } else if (x > xBar + self.bar[self.origin.offset]) {
                        sign = 1;
                    }

                    var y = self.pos() + sign * screen * self.scroller[self.origin.client];
                    self.pos(y);
                });
            }
        }

    };

    baron.fn.controls = function(params) {
        var i = 0;

        while (this[i]) {
            controls.call(this[i], params);
            i++;
        }

        return this;
    };
})(window);

================================================
FILE: vendors/baron/src/core.js
================================================
(function(window, undefined) {
    'use strict';

    if (!window) return; // Server side

var
    _baron = window.baron, // Stored baron value for noConflict usage
    $ = window.jQuery, // Trying to use jQuery
    origin = {
        v: { // Vertical
            x: 'Y', pos: 'top', crossPos: 'left', size: 'height', crossSize: 'width',
            client: 'clientHeight', crossClient: 'clientWidth', offset: 'offsetHeight', crossOffset: 'offsetWidth', offsetPos: 'offsetTop',
            scroll: 'scrollTop', scrollSize: 'scrollHeight'
        },
        h: { // Horizontal
            x: 'X', pos: 'left', crossPos: 'top', size: 'width', crossSize: 'height',
            client: 'clientWidth', crossClient: 'clientHeight', offset: 'offsetWidth', crossOffset: 'offsetHeight', offsetPos: 'offsetLeft',
            scroll: 'scrollLeft', scrollSize: 'scrollWidth'
        }
    },

    each = function(obj, iterator) {
        var i = 0;

        if (obj.length === undefined || obj === window) obj = [obj];

        while (obj[i]) {
            iterator.call(this, obj[i], i);
            i++;
        }
    },

    baron = function(params) { // this - window or jQuery instance
        var jQueryMode = (this && this[0] && this[0].nodeType),
            roots,
            $;

        params = params || {};
        $ = params.$ || window.jQuery;

        if (jQueryMode) {
            params.root = roots = this;
        } else {
            roots = $(params.root || params.scroller);
        }

        return new baron.fn.constructor(roots, params, $);
    };

    baron.fn = {
        constructor: function(roots, input, $) {
            var params = validate(input);

            params.$ = $;
            each.call(this, roots, function(root, i) {
                var localParams = clone(params);

                if (params.root && params.scroller) {
                    localParams.scroller = params.$(params.scroller, root);
                    if (!localParams.scroller.length) {
                        localParams.scroller = root;
                    }
                } else {
                    localParams.scroller = root;
                }

                localParams.root = root;
                this[i] = init(localParams);
                this.length = i + 1;
            });

            this.params = params;
        },

        dispose: function() {
            var params = this.params;

            each(this, function(item) {
                item.dispose(params);
            });
            this.params = null;
        },

        update: function() {
            var i = 0;

            while (this[i]) {
                this[i].update.apply(this[i], arguments);
                i++;
            }
        },

        baron: function(params) {
            params.root = [];
            params.scroller = this.params.scroller;

            each.call(this, this, function(elem) {
                params.root.push(elem.root);
            });
            params.direction = (this.params.direction == 'v') ? 'h' : 'v';
            params._chain = true;

            return baron(params);
        }
    };

    function manageEvents(item, eventManager, mode) {
        item._eventHandlers = item._eventHandlers || [ // Creating new functions for one baron item only one time
            {
                // onScroll: 
                element: item.scroller,

                handler: function(e) {
                    item.scroll(e);
                },

                type: 'scroll'
            }, {
                // onMouseDown: 
                element: item.bar,

                handler: function(e) {
                    e.preventDefault(); // Text selection disabling in Opera... and all other browsers?
                    item.selection(); // Disable text selection in ie8
                    item.drag.now = 1; // Save private byte
                },

                type: 'touchstart mousedown'
            }, {
                // onMouseUp: 
                element: document,

                handler: function() {
                    item.selection(1); // Enable text selection
                    item.drag.now = 0;
                },

                type: 'mouseup blur touchend'
            }, {
                // onCoordinateReset: 
                element: document,

                handler: function(e) {
                    if (e.button != 2) { // Not RM
                        item._pos0(e);
                    }
                },

                type: 'touchstart mousedown'
            }, {
                // onMouseMove: 
                element: document,

                handler: function(e) {
                    if (item.drag.now) {
                        item.drag(e);
                    }
                },

                type: 'mousemove touchmove'
            }, {
                // onResize: 
                element: window,

                handler: function() {
                    item.update();
                },

                type: 'resize'
            }, {
                // sizeChange: 
                element: item.root,

                handler: function() {
                    item.update();
                },

                type: 'sizeChange'
            }
        ];

        each(item._eventHandlers, function(event) {
            if (event.element) {
                eventManager(event.element, event.type, event.handler, mode);
            }
        });

        // if (item.scroller) {
        //     event(item.scroller, 'scroll', item._eventHandlers.onScroll, mode);
        // }
        // if (item.bar) {
        //     event(item.bar, 'touchstart mousedown', item._eventHandlers.onMouseDown, mode);
        // }
        // event(document, 'mouseup blur touchend', item._eventHandlers.onMouseUp, mode);
        // event(document, 'touchstart mousedown', item._eventHandlers.onCoordinateReset, mode);
        // event(document, 'mousemove touchmove', item._eventHandlers.onMouseMove, mode);
        // event(window, 'resize', item._eventHandlers.onResize, mode);
        // if (item.root) {
        //     event(item.root, 'sizeChange', item._eventHandlers.onResize, mode); // Custon event for alternate baron update mechanism
        // }
    }

    function manageAttr(node, direction, mode) {
        var attrName = 'data-baron-' + direction;

        if (mode == 'on') {
            node.setAttribute(attrName, 'inited');
        } else if (mode == 'off') {
            node.removeAttribute(attrName);
        } else {
            return node.getAttribute(attrName);
        }
    }

    function init(params) {
        if (manageAttr(params.root, params.direction)) return;

        var out = new item.prototype.constructor(params); // __proto__ of returning object is baron.prototype

        manageEvents(out, params.event, 'on');

        manageAttr(out.root, params.direction, 'on');

        out.update();

        return out;
    }

    function clone(input) {
        var output = {};

        input = input || {};

        for (var key in input) {
            if (input.hasOwnProperty(key)) {
                output[key] = input[key];
            }
        }

        return output;
    }

    function validate(input) {
        var output = clone(input);

        output.direction = output.direction || 'v';

        var event = input.event || function(elem, event, func, mode) {
            output.$(elem)[mode || 'on'](event, func);
        };

        output.event = function(elems, e, func, mode) {
            each(elems, function(elem) {
                event(elem, e, func, mode);
            });
        };

        return output;
    }

    function fire(eventName) {
        /* jshint validthis:true */
        if (this.events && this.events[eventName]) {
            for (var i = 0 ; i < this.events[eventName].length ; i++) {
                var args = Array.prototype.slice.call( arguments, 1 );

                this.events[eventName][i].apply(this, args);
            }
        }
    }

    var item = {};

    item.prototype = {
        constructor: function(params) {
            var $,
                barPos,
                scrollerPos0,
                track,
                resizePauseTimer,
                scrollPauseTimer,
                pause,
                scrollLastFire,
                resizeLastFire;

            resizeLastFire = scrollLastFire = new Date().getTime();

            $ = this.$ = params.$;
            this.event = params.event;
            this.events = {};

            function getNode(sel, context) {
                return $(sel, context)[0]; // Can be undefined
            }

            // DOM elements
            this.root = params.root; // Always html node, not just selector
            this.scroller = getNode(params.scroller); // (params.scroller) ? getNode(params.scroller, this.root) : this.root;
            this.bar = getNode(params.bar, this.root);
            track = this.track = getNode(params.track, this.root);
            if (!this.track && this.bar) {
                track = this.bar.parentNode;
            }
            this.clipper = this.scroller.parentNode;

            // Parameters
            this.direction = params.direction;
            this.origin = origin[this.direction];
            this.barOnCls = params.barOnCls;
            this.barTopLimit = 0;
            pause = params.pause * 1000 || 0;

            // Updating height or width of bar
            function setBarSize(size) {
                /* jshint validthis:true */
                var barMinSize = this.barMinSize || 20;

                if (size > 0 && size < barMinSize) {
                    size = barMinSize;
                }

                if (this.bar) {
                    $(this.bar).css(this.origin.size, parseInt(size, 10) + 'px');
                }
            }

            // Updating top or left bar position
            function posBar(pos) {
                /* jshint validthis:true */
                if (this.bar) {
                    $(this.bar).css(this.origin.pos, +pos + 'px');
                }
            }

            // Free path for bar
            function k() {
                /* jshint validthis:true */
                return track[this.origin.client] - this.barTopLimit - this.bar[this.origin.offset];
            }

            // Relative content top position to bar top position
            function relToPos(r) {
                /* jshint validthis:true */
                return r * k.call(this) + this.barTopLimit;
            }

            // Bar position to relative content position
            function posToRel(t) {
                /* jshint validthis:true */
                return (t - this.barTopLimit) / k.call(this);
            }

            // Cursor position in main direction in px // Now with iOs support
            this.cursor = function(e) {
                return e['client' + this.origin.x] || (((e.originalEvent || e).touches || {})[0] || {})['page' + this.origin.x];
            };

            // Text selection pos preventing
            function dontPosSelect() {
                return false;
            }

            this.pos = function(x) { // Absolute scroller position in px
                var ie = 'page' + this.origin.x + 'Offset',
                    key = (this.scroller[ie]) ? ie : this.origin.scroll;

                if (x !== undefined) this.scroller[key] = x;

                return this.scroller[key];
            };

            this.rpos = function(r) { // Relative scroller position (0..1)
                var free = this.scroller[this.origin.scrollSize] - this.scroller[this.origin.client],
                    x;

                if (r) x = this.pos(r * free);
                else x = this.pos();

                return x / (free || 1);
            };

            // Switch on the bar by adding user-defined CSS classname to scroller
            this.barOn = function(dispose) {
                if (this.barOnCls) {
                    if (dispose || this.scroller[this.origin.client] >= this.scroller[this.origin.scrollSize]) {
                        $(this.root).removeClass(this.barOnCls);
                    } else {
                        $(this.root).addClass(this.barOnCls);
                    }
                }
            };

            this._pos0 = function(e) {
                scrollerPos0 = this.cursor(e) - barPos;
            };

            this.drag = function(e) {
                this.scroller[this.origin.scroll] = posToRel.call(this, this.cursor(e) - scrollerPos0) * (this.scroller[this.origin.scrollSize] - this.scroller[this.origin.client]);
            };

            // Text selection preventing on drag
            this.selection = function(enable) {
                this.event(document, 'selectpos selectstart', dontPosSelect, enable ? 'off' : 'on');
            };

            // onResize & DOM modified handler
            this.resize = function() {
                var self = this,
                    delay = 0;

                if (new Date().getTime() - resizeLastFire < pause) {
                    clearTimeout(resizePauseTimer);
                    delay = pause;
                }

                function upd() {
                    var delta = self.scroller[self.origin.crossOffset] - self.scroller[self.origin.crossClient];

                    if (params.freeze && !self.clipper.style[self.origin.crossSize]) { // Sould fire only once
                        $(self.clipper).css(self.origin.crossSize, self.clipper[self.origin.crossClient] - delta + 'px');
                    }
                    $(self.scroller).css(self.origin.crossSize, self.clipper[self.origin.crossClient] + delta + 'px');
                    
                    Array.prototype.unshift.call(arguments, 'resize');
                    fire.apply(self, arguments);

                    resizeLastFire = new Date().getTime();
                }

                if (delay) {
                    resizePauseTimer = setTimeout(upd, delay);
                } else {
                    upd();
                }
            };

            // onScroll handler
            this.scroll = function() {
                var oldBarSize, newBarSize,
                    delay = 0,
                    self = this;

                if (new Date().getTime() - scrollLastFire < pause) {
                    clearTimeout(scrollPauseTimer);
                    delay = pause;
                }

                function upd() {
                    if (self.bar) {
                        newBarSize = (track[self.origin.client] - self.barTopLimit) * self.scroller[self.origin.client] / self.scroller[self.origin.scrollSize];

                        // Positioning bar
                        if (oldBarSize != newBarSize) {
                            setBarSize.call(self, newBarSize);
                            oldBarSize = newBarSize;
                        }
                        
                        barPos = relToPos.call(self, self.rpos());

                        posBar.call(self, barPos);
                    }

                    Array.prototype.unshift.call( arguments, 'scroll' );
                    fire.apply(self, arguments);

                    scrollLastFire = new Date().getTime();
                }

                if (delay) {
                    scrollPauseTimer = setTimeout(upd, delay);
                } else {
                    upd();
                }
                
            };

            return this;
        },

        update: function(params) {
            fire.call(this, 'upd', params); // Обновляем параметры всех плагинов

            this.resize(1);
            this.barOn();
            this.scroll();

            return this;
        },

        dispose: function(params) {
            manageEvents(this, this.event, 'off');
            manageAttr(this.root, params.direction, 'off');
            $(this.scroller).css(this.origin.crossSize, '');
            this.barOn(true);
            fire.call(this, 'dispose');
        },

        on: function(eventName, func, arg) {
            var names = eventName.split(' ');

            for (var i = 0 ; i < names.length ; i++) {
                if (names[i] == 'init') {
                    func.call(this, arg);
                } else {
                    this.events[names[i]] = this.events[names[i]] || [];

                    this.events[names[i]].push(function(userArg) {
                        func.call(this, userArg || arg);
                    });
                }
            }
        }
    };

    baron.fn.constructor.prototype = baron.fn;
    item.prototype.constructor.prototype = item.prototype;

    // Use when you need "baron" global var for another purposes
    baron.noConflict = function() {
        window.baron = _baron; // Restoring original value of "baron" global var

        return baron;
    };

    baron.version = '0.6.6';

    if ($ && $.fn) { // Adding baron to jQuery as plugin
        $.fn.baron = baron;
    }
    window.baron = baron; // Use noConflict method if you need window.baron var for another purposes
    if (window['module'] && module.exports) {
        module.exports = baron.noConflict();
    }
})(window);

================================================
FILE: vendors/baron/src/fix.js
================================================
/* Fixable elements plugin for baron 0.6+ */
(function(window, undefined) {
    var fix = function(userParams) {
        var elements, viewPortSize,
            params = { // Default params
                outside: '',
                before: '',
                after: '',
                past: '',
                future: '',
                radius: 0,
                minView: 0
            },
            topFixHeights = [], // inline style for element
            topRealHeights = [], // real offset position when not fixed
            headerTops = [],
            scroller = this.scroller,
            eventManager = this.event,
            $ = this.$,
            self = this;

        function fixElement(i, pos) {
            if (viewPortSize < (params.minView || 0)) { // No headers fixing when no enought space for viewport
                pos = undefined;
            }

            if (pos !== undefined) {
                pos += 'px';
                this.$(elements[i]).css(this.origin.pos, pos).addClass(params.outside);
            } else {
                this.$(elements[i]).css(this.origin.pos, '').removeClass(params.outside);
            }
        }

        function bubbleWheel(e) {
            try {
                i = document.createEvent('WheelEvent'); // i - for extra byte
                // evt.initWebKitWheelEvent(deltaX, deltaY, window, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey);
                i.initWebKitWheelEvent(e.originalEvent.wheelDeltaX, e.originalEvent.wheelDeltaY);
                scroller.dispatchEvent(i);
                e.preventDefault();
            } catch (e) {}
        }

        function init(_params) {
            var pos;

            for (var key in _params) {
                params[key] = _params[key];
            }

            elements = this.$(params.elements, this.scroller);

            if (elements) {
                viewPortSize = this.scroller[this.origin.client];
                for (var i = 0 ; i < elements.length ; i++) {
                    // Variable header heights
                    pos = {};
                    pos[this.origin.size] = elements[i][this.origin.offset];
                    if (elements[i].parentNode !== this.scroller) {
                        this.$(elements[i].parentNode).css(pos);
                    }
                    pos = {};
                    pos[this.origin.crossSize] = elements[i].parentNode[this.origin.crossClient];
                    this.$(elements[i]).css(pos);

                    // Between fixed headers
                    viewPortSize -= elements[i][this.origin.offset];

                    headerTops[i] = elements[i].parentNode[this.origin.offsetPos]; // No paddings for parentNode

                    // Summary elements height above current
                    topFixHeights[i] = (topFixHeights[i - 1] || 0); // Not zero because of negative margins
                    topRealHeights[i] = (topRealHeights[i - 1] || Math.min(headerTops[i], 0));

                    if (elements[i - 1]) {
                        topFixHeights[i] += elements[i - 1][this.origin.offset];
                        topRealHeights[i] += elements[i - 1][this.origin.offset];
                    }

                    if ( !(i == 0 && headerTops[i] == 0)/* && force */) {
                        this.event(elements[i], 'mousewheel', bubbleWheel, 'off');
                        this.event(elements[i], 'mousewheel', bubbleWheel);
                    }
                }

                if (params.limiter && elements[0]) { // Bottom edge of first header as top limit for track
                    if (this.track && this.track != this.scroller) {
                        pos = {};
                        pos[this.origin.pos] = elements[0].parentNode[this.origin.offset];
                        this.$(this.track).css(pos);
                    } else {
                        this.barTopLimit = elements[0].parentNode[this.origin.offset];
                    }
                    // this.barTopLimit = elements[0].parentNode[this.origin.offset];
                    this.scroll();
                }

                if (params.limiter === false) { // undefined (in second fix instance) should have no influence on bar limit
                    this.barTopLimit = 0;
                }
            }

            var event = {
                element: elements,
                
                handler: function() {
                    var parent = $(this)[0].parentNode,
                        top = parent.offsetTop,
                        num;

                    // finding num -> elements[num] === this
                    for (var i = 0 ; i < elements.length ; i++ ) {
                        if (elements[i] === this) num = i;
                    }

                    var pos = top - topFixHeights[num];

                    if (params.scroll) { // User defined callback
                        params.scroll({
                            x1: self.scroller.scrollTop,
                            x2: pos
                        });
                    } else {
                        self.scroller.scrollTop = pos;
                    }
                },

                type: 'click'
            };

            if (params.clickable) {
                this._eventHandlers.push(event); // For auto-dispose
                eventManager(event.element, event.type, event.handler, 'off');
                eventManager(event.element, event.type, event.handler, 'on');
            }
        }

        this.on('init', init, userParams);

        this.on('init scroll', function() {
            var fixState, hTop,
                fixFlag = []; // 1 - past, 2 - future, 3 - current (not fixed)

            if (elements) {
                var change;

                // fixFlag update
                for (var i = 0 ; i < elements.length ; i++) {
                    fixState = 0;
                    if (headerTops[i] - this.pos() < topRealHeights[i] + params.radius) {
                        // Header trying to go up
                        fixState = 1;
                        hTop = topFixHeights[i];
                    } else if (headerTops[i] - this.pos() > topRealHeights[i] + viewPortSize - params.radius) {
                        // Header trying to go down
                        fixState = 2;
                        hTop = topFixHeights[i] + viewPortSize;
                    } else {
                        // Header in viewport
                        fixState = 3;
                        hTop = undefined;
                    }
                    if (fixState != fixFlag[i]) {
                        fixElement.call(this, i, hTop);
                        fixFlag[i] = fixState;
                        change = true;
                    }
                }

                // Adding positioning classes (on last top and first bottom header)
                if (change) { // At leats one change in elements flag structure occured
                    for (i = 0 ; i < elements.length ; i++) {
                        if (fixFlag[i] == 1 && params.past) {
                            this.$(elements[i]).addClass(params.past).removeClass(params.future);
                        }

                        if (fixFlag[i] == 2 && params.future) {
                            this.$(elements[i]).addClass(params.future).removeClass(params.past);
                        }

                        if (fixFlag[i] == 3 && (params.future || params.past)) {
                            this.$(elements[i]).removeClass(params.past).removeClass(params.future);
                        }

                        if (fixFlag[i] != fixFlag[i + 1] && fixFlag[i] == 1 && params.before) {
                            this.$(elements[i]).addClass(params.before).removeClass(params.after); // Last top fixed header
                        } else if (fixFlag[i] != fixFlag[i - 1] && fixFlag[i] == 2 && params.after) {
                            this.$(elements[i]).addClass(params.after).removeClass(params.before); // First bottom fixed header
                        } else {
                            this.$(elements[i]).removeClass(params.before).removeClass(params.after);
                        }
                    }
                }
            }
        });

        this.on('resize upd', function(updParams) {
            init.call(this, updParams && updParams.fix);
        });
    };

    baron.fn.fix = function(params) {
        var i = 0;

        while (this[i]) {
            fix.call(this[i], params);
            i++;
        }

        return this;
    };
})(window);

================================================
FILE: vendors/baron/src/pull.js
================================================
/* Pull to load plugin for baron 0.6+ */
(function(window, undefined) {
    var pull = function(params) {
        var block = this.$(params.block),
            size = params.size || this.origin.size,
            limit = params.limit || 80,
            onExpand = params.onExpand,
            elements = params.elements || [],
            inProgress = params.inProgress || '',
            self = this,
            _insistence = 0,
            _zeroXCount = 0,
            _interval,
            _timer,
            _x = 0,
            _onExpandCalled,
            _waiting = params.waiting || 500,
            _on;

        function getSize() {
            return self.scroller[self.origin.scroll] + self.scroller[self.origin.offset];
        }

        // Scroller content height
        function getContentSize() {
            return self.scroller[self.origin.scrollSize];
        }

        // Scroller height
        function getScrollerSize() {
            return self.scroller[self.origin.client];
        }

        function step(x, force) {
            var k = x * 0.0005;
            
            return Math.floor(force - k * (x + 550));
        }

        function toggle(on) {
            _on = on;

            if (on) {
                update(); // First time with no delay
                _interval = setInterval(update, 200);
            } else {
                clearInterval(_interval);
            }
        }

        function update() {
            var pos = {},
                height = getSize(),
                scrollHeight = getContentSize(),
                dx,
                op4,
                scrollInProgress = _insistence == 1;

            op4 = 0; // Возвращающая сила
            if (_insistence > 0) {
                op4 = 40;
            }
            //if (_insistence > -1) {
                dx = step(_x, op4);
                if (height >= scrollHeight - _x && _insistence > -1) {
                    if (scrollInProgress) {
                        _x += dx;
                    }
                } else {
                    _x = 0;
                }

                if (_x < 0) _x = 0;

                pos[size] = _x + 'px';
                if (getScrollerSize() <= getContentSize()) {
                    self.$(block).css(pos);
                    for (var i = 0 ; i < elements.length ; i++) {
                        self.$(elements[i].self).css(elements[i].property, Math.min(_x / limit * 100, 100) + '%');
                    }
                }

                if (inProgress && _x) {
                    self.$(self.root).addClass(inProgress);
                }

                if (_x == 0) {
                    if (params.onCollapse) {
                        params.onCollapse();
                    }
                }

                _insistence = 0;
                _timer = setTimeout(function() {
                    _insistence = -1;
                }, _waiting);
            //}

            if (onExpand && _x > limit && !_onExpandCalled) {
                onExpand();
                _onExpandCalled = true;
            }

            if (_x == 0) {
                _zeroXCount++;
            } else {
                _zeroXCount = 0;
                
            }
            if (_zeroXCount > 1) {
                toggle(false);
                _onExpandCalled = false;
                if (inProgress) {
                    self.$(self.root).removeClass(inProgress);
                }
            }
        }

        this.on('init', function() {
            toggle(true);
        });

        this.on('dispose', function() {
            toggle(false);
        });

        this.event(this.scroller, 'mousewheel DOMMouseScroll', function(e) {
            var down = e.wheelDelta < 0 || (e.originalEvent && e.originalEvent.wheelDelta < 0) || e.detail > 0;

            if (down) {
                _insistence = 1;
                clearTimeout(_timer);
                if (!_on && getSize() >= getContentSize()) {
                    toggle(true);
                }
            }
            //  else {
            //     toggle(false);
            // }
        });
    };

    baron.fn.pull = function(params) {
        var i = 0;

        while (this[i]) {
            pull.call(this[i], params);
            i++;
        }

        return this;
    };
})(window);

================================================
FILE: vendors/baron/src/test.js
================================================
/* Autotests plugin for baron 0.6+ (for developers) */
(function(window, undefined) {
    var test = function(params) {
        var errCount = 0,
            totalCount = 0;

        var log = function(type, msg, obj) {
            var text = type + ': ' + msg;

            switch (type) {
                case 'log': css = 'color: #0b0'; break;
                case 'warn': css = 'color: #fc9'; break;
                case 'error': css = 'color: #f00'; break;
            }
            totalCount++;
            if (type == 'log') {
                errCount++;
            }

            console.log('%c ' + totalCount + '. ' + text, css);
            if (obj !== undefined) {
                console.log(obj);
            }
        };

        if (this.scroller && this.scroller.nodeType === 1) {
            log('log', 'Scroller defined and has proper nodeType value', this.scroller);
        } else {
            log('error', 'Scroller not defined or has wrong type (should be html node).', this.scroller);
        }

        if (this.$ && typeof this.$ == 'function') {
            log('log', 'Local $ defined and it is a function');
        } else {
            log('error', 'Local $ has wrong value or is not defined, or custom params.dom and params.selector not defined', params.$);
        }

        if (this.scroller.getAttribute('data-baron-v')) {
            log('log', 'Baron initialized in vertical direction', this.scroller.getAttribute('data-baron-v'));
            if (this.scroller.clientHeight < this.scroller.scrollHeight && this.scroller.getAttribute('data-baron-v')) {
                log('log', 'There are enought space for scrolling in vertical direction right now', this.scroller.scrollHeight - this.scroller.clientHeight + 'px');
            } else {
                log('log', 'There are not enought space for scrolling in vertical direction right now');
            }
        }
        if (this.scroller.getAttribute('data-baron-h')) {
            log('log', 'Baron initialized in horizontal direction', this.scroller.getAttribute('data-baron-h'));
            if (this.scroller.clientWidth < this.scroller.scrollWidth) {
                log('log', 'There are enought space for scrolling in horizontal direction right now', this.scroller.scrollWidth - this.scroller.clientWidth + 'px');
            } else {
                log('log', 'There are not enought space for scrolling in horizontal direction right now');
            }
        }

        if (this.bar && this.bar.nodeType === 1) {
            log('log', 'Bar defined and has proper nodeType value', this.bar);
        } else {
            log('warn', 'Bar not defined or has wrong type (should be html node).', this.bar);
        }
        
        if (this.barOnCls) {
            log('log', 'CSS classname barOnCls defined', this.barOnCls);
        } else {
            log('warn', 'barOnCls not defined - bar will be visible or not visible all the time', this.barOnCls);
        }

        // Preformance test
        var t1 = new Date().getTime(),
            x;
        for (var i = 0 ; i < 1000 ; i += 10) {
            x = i % (this.scroller[this.origin.scrollSize] - this.scroller[this.origin.client]);
            this.pos(x);
            this.event(this.scroller, 'scroll', undefined, 'trigger');
        }
        var t2 = new Date().getTime();
        log('log', 'Preformance test: ' + (t2 - t1) / 1000 + ' milliseconds per scroll event');
        
        log('log', 'Result is ' + errCount + ' / ' + totalCount + '\n');
    };

    baron.fn.test = function(params) {
        var i = 0;

        while (this[i]) {
            test.call(this[i], params);
            i++;
        }

        return this;
    };
})(window);

================================================
FILE: vendors/baron/tasks/mocha-phantomjs.js
================================================
/*
 * grunt-mocha-phantomjs
 * https://github.com/jdcataldo/grunt-mocha-phantomjs
 *
 * Copyright (c) 2013 Justin Cataldo
 * Licensed under the MIT license.
 */

'use strict';

module.exports = function(grunt) {
    var util    = grunt.util,
    // Alias for Lo-Dash
        _       = util._,
        path = require("path"),
        exists = grunt.file.exists;

    grunt.registerMultiTask('mocha-phantomjs', 'Run client-side mocha test with phantomjs.', function() {
        // Merge options
        var options        = this.options({
                reporter: 'spec',
                // Non file urls to test
                urls: [],
                verbose: false
            }),
            args           = [],
            binPath        = '.bin/mocha-phantomjs' + (process.platform === 'win32' ? '.cmd' : ''),
            phantomjs_path = path.join(__dirname, '..', '/node_modules/', binPath),
            urls           = options.urls.concat(this.filesSrc),
            done           = this.async(),
            errors         = 0,
            results        = '',
            output         = options.output || false;

        // Check for a local install of mocha-phantomjs to use
        if (!exists(phantomjs_path)) {
            var i = module.paths.length,
                bin;
            while(i--) {
                bin = path.join(module.paths[i], binPath);
                if (exists(bin)) {
                    phantomjs_path = bin;
                    break;
                }
            }
        }

        if(!exists(phantomjs_path)) {
            grunt.fail.warn('Unable to find mocha-phantomjs.');
        }

        // Loop through the options and add them to args
        // Omit urls from the options to be passed through
        _.each(_.omit(options, 'urls', 'output'), function(value, key) {
            // Convert to the key to a switch
            var sw = (key.length > 1 ? '--' : '-') + key;
            // Add the switch and its value
            // If the value is an array, add all array elements to the array.
            if(!_.isArray(value)) {
                value = [value];
            }

            _.each(value, function(value) {
                args.push([sw, value.toString()]);
            });
        });

        util.async.forEachSeries(urls, function(f, next) {
            var phantomjs = grunt.util.spawn({
                cmd: phantomjs_path,
                args: _.flatten([f].concat(args))
            }, function(error, result, code) {
                next();
            });

            phantomjs.stdout.pipe(process.stdout);
            phantomjs.stderr.pipe(process.stderr);

            // Append output to be written to a file
            if(output) {
                phantomjs.stdout.on('data', function(data){
                    results += String(data.toString());
                });
            }

            phantomjs.on('exit', function(code){
                if (code === 127) {
                    grunt.fail.warn("Phantomjs isn't installed");
                }
                errors += code;
            });

        }, function(){
            // Fail if errors are reported and we aren't outputing to a file
            if(!output && errors > 0) {
                grunt.fail.warn(errors + " tests failed");
            } else if(output) {
                grunt.file.write(output, results);
            }
            done();
        });
    });

};

================================================
FILE: vendors/baron/test/core.auto.html
================================================
<!doctype html>
<html>
<head>

    <meta charset="utf-8" />

    <script src="../js/jquery-1.9.0.js"></script>

    <script src="../js/qwery.js"></script>
    <script src="../js/bonzo.js"></script>
    <script src="../js/bean.js"></script>

    <script src="../src/core.js"></script>
    <script src="../src/fix.js"></script>
    <script src="../src/pull.js"></script>
    <script src="../src/test.js"></script>
    <script src="../src/controls.js"></script>

    <link rel="stylesheet" type="text/css" href="../baron.css" />
    <link rel="stylesheet" type="text/css" href="style.css" />
    <link rel="stylesheet" href="../node_modules/mocha/mocha.css" />
    <style>
        .wrapper {
            width: 200px;
        }
        .test {
            display: block;
            height: auto;
            width: auto;
            background: #fff;
            box-shadow: none;
        }
    </style>

    <title>Baron test page</title>

</head>

<body>
    <div id="mocha"></div>
    <script src="../node_modules/mocha/mocha.js"></script>
    <script src="../node_modules/chai/chai.js"></script>
    <script>
        var assert = chai.assert;

        mocha.ui('bdd');
        mocha.reporter('html');
    </script>

    <div class="wrapper wrapper_headers">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">Baron</h1>
                </div>
                <p class="text">is the third most populous city in Russia after Moscow and St. Petersburg and the most populous city in Asian Russia, with a population of 1,473,754 (2010 Census). It is the administrative center of Novosibirsk Oblast as well as of Siberian Federal District. The city is located in the southwestern part of Siberia at the banks of the Ob River and occupies an area of 502.1 square kilometers (193.9 sq mi).</p>
                <div class="header">
                    <h1 class="header__title">Baron</h1>
                </div>
                <p class="text">Novosibirsk, founded in 1893 at the future site of a Trans-Siberian Railway bridge crossing the great Siberian river of Ob, first received the name Novonikolayevsk (Новониколаевск), in honor both of Saint Nicholas and of the reigning Tsar Nicholas II. The bridge was completed in the spring of 1897, making the new settlement the regional transport hub. The importance of the city further increased with the completion of the Turkestan-Siberia Railway in the early 20th century. The new railway connected Novosibirsk to Central Asia and the Caspian Sea.</p>
                <div class="header">
                    <h1 class="header__title">Baron</h1>
                </div>
                <p class="text">...of the bridge's opening, Novonikolayevsk hosted a population of 7,800 people. Its first bank opened in 1906, with a total of five banks operating by 1915. In 1907, Novonikolayevsk, now with a population exceeding 47,000, was granted town status with full rights for self-government. The pre-revolutionary period saw the population of Novosibirsk reach 80,000. During this period the city experienced steady and rapid economic growth, becoming one of the largest commercial and industrial centers of Siberia and developing a significant agricultural processing industry, as well as a power station, iron foundry, commodity market, several banks, and commercial and shipping companies. By 1917, Novosibirsk possessed seven Orthodox churches and one Roman Catholic church, several cinemas, forty primary schools, a high school, a teaching seminary, and the Romanov House non-classical secondary school. In 1913, Novonikolayevsk became one of the first places in Russia to institute compulsory primary education.</p>
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>

    <div class="wrapper wrapper_">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">Baron</h1>
                </div>
                <p class="text">is the third most populous city in Russia after Moscow and St. Petersburg and the most populous city in Asian Russia, with a population of 1,473,754 (2010 Census). It is the administrative center of Novosibirsk Oblast as well as of Siberian Federal District. The city is located in the southwestern part of Siberia at the banks of the Ob River and occupies an area of 502.1 square kilometers (193.9 sq mi).</p>
                <div class="header">
                    <h1 class="header__title">Baron</h1>
                </div>
                <p class="text">Novosibirsk, founded in 1893 at the future site of a Trans-Siberian Railway bridge crossing the great Siberian river of Ob, first received the name Novonikolayevsk (Новониколаевск), in honor both of Saint Nicholas and of the reigning Tsar Nicholas II. The bridge was completed in the spring of 1897, making the new settlement the regional transport hub. The importance of the city further increased with the completion of the Turkestan-Siberia Railway in the early 20th century. The new railway connected Novosibirsk to Central Asia and the Caspian Sea.</p>
                <div class="header">
                    <h1 class="header__title">Baron</h1>
                </div>
                <p class="text">...of the bridge's opening, Novonikolayevsk hosted a population of 7,800 people. Its first bank opened in 1906, with a total of five banks operating by 1915. In 1907, Novonikolayevsk, now with a population exceeding 47,000, was granted town status with full rights for self-government. The pre-revolutionary period saw the population of Novosibirsk reach 80,000. During this period the city experienced steady and rapid economic growth, becoming one of the largest commercial and industrial centers of Siberia and developing a significant agricultural processing industry, as well as a power station, iron foundry, commodity market, several banks, and commercial and shipping companies. By 1917, Novosibirsk possessed seven Orthodox churches and one Roman Catholic church, several cinemas, forty primary schools, a high school, a teaching seminary, and the Romanov House non-classical secondary school. In 1913, Novonikolayevsk became one of the first places in Russia to institute compulsory primary education.</p>
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>

    <script src="tests.js"></script>

    <script>
        if (window.mochaPhantomJS) { mochaPhantomJS.run(); }
        else { mocha.run(); }
    </script>

</body>

</html>

================================================
FILE: vendors/baron/test/index.html
================================================
<!doctype html>
<html>
<head>

    <meta charset="utf-8" />

    <script src="../js/jquery-1.9.0.js"></script>

    <script src="../js/qwery.js"></script>
    <script src="../js/bonzo.js"></script>
    <script src="../js/bean.js"></script>

    <script>
        var baron = 5; // noConflict usage test (see console logs)
        // var module = { // require() test
        //     exports: function() {}
        // }
    </script>

    <script src="../src/core.js"></script>
    <script src="../src/fix.js"></script>
    <script src="../src/test.js"></script>
    <script src="../src/controls.js"></script>
    <script src="script.js"></script>

    <link rel="stylesheet" type="text/css" href="../baron.css" />
    <link rel="stylesheet" type="text/css" href="style.css" />

    <title>Baron test page</title>

</head>

<body>

<div class="test test_very-simple">
    <div class="test__description">
        Simple
    </div>
    <div class="wrapper wrapper_very-simple">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">Climate</h1>
                </div>
                <p class="text">is the third most populous city in Russia after Moscow and St. Petersburg and the most populous city in Asian Russia, with a population of 1,473,754 (2010 Census). It is the administrative center of Novosibirsk Oblast as well as of Siberian Federal District. The city is located in the southwestern part of Siberia at the banks of the Ob River and occupies an area of 502.1 square kilometers (193.9 sq mi).</p>
                <div class="header">
                    <h1 class="header__title">History</h1>
                </div>
                <p class="text">Novosibirsk, founded in 1893 at the future site of a Trans-Siberian Railway bridge crossing the great Siberian river of Ob, first received the name Novonikolayevsk (Новониколаевск), in honor both of Saint Nicholas and of the reigning Tsar Nicholas II. The bridge was completed in the spring of 1897, making the new settlement the regional transport hub. The importance of the city further increased with the completion of the Turkestan-Siberia Railway in the early 20th century. The new railway connected Novosibirsk to Central Asia and the Caspian Sea.</p>


                <div class="header">
                    <h1 class="header__title">At the time...</h1>
                </div>
                <p class="text">...of the bridge's opening, Novonikolayevsk hosted a population of 7,800 people. Its first bank opened in 1906, with a total of five banks operating by 1915. In 1907, Novonikolayevsk, now with a population exceeding 47,000, was granted town status with full rights for self-government. The pre-revolutionary period saw the population of Novosibirsk reach 80,000. During this period the city experienced steady and rapid economic growth, becoming one of the largest commercial and industrial centers of Siberia and developing a significant agricultural processing industry, as well as a power station, iron foundry, commodity market, several banks, and commercial and shipping companies. By 1917, Novosibirsk possessed seven Orthodox churches and one Roman Catholic church, several cinemas, forty primary schools, a high school, a teaching seminary, and the Romanov House non-classical secondary school. In 1913, Novonikolayevsk became one of the first places in Russia to institute compulsory primary education.</p>                
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>
</div>


<div class="test test_simple">
    <div class="test__description">
        With fixable elements, radius 30 px, no bar.
    </div>
    <div class="wrapper wrapper_simple">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">Climate</h1>
                </div>
                <p class="text">is the third most populous city in Russia after Moscow and St. Petersburg and the most populous city in Asian Russia, with a population of 1,473,754 (2010 Census). It is the administrative center of Novosibirsk Oblast as well as of Siberian Federal District. The city is located in the southwestern part of Siberia at the banks of the Ob River and occupies an area of 502.1 square kilometers (193.9 sq mi).</p>
                <div class="header">
                    <h1 class="header__title">History</h1>
                </div>
                <p class="text">Novosibirsk, founded in 1893 at the future site of a Trans-Siberian Railway bridge crossing the great Siberian river of Ob, first received the name Novonikolayevsk (Новониколаевск), in honor both of Saint Nicholas and of the reigning Tsar Nicholas II. The bridge was completed in the spring of 1897, making the new settlement the regional transport hub. The importance of the city further increased with the completion of the Turkestan-Siberia Railway in the early 20th century. The new railway connected Novosibirsk to Central Asia and the Caspian Sea.</p>


                <div class="header">
                    <h1 class="header__title">At the time...</h1>
                </div>
                <p class="text">...of the bridge's opening, Novonikolayevsk hosted a population of 7,800 people. Its first bank opened in 1906, with a total of five banks operating by 1915. In 1907, Novonikolayevsk, now with a population exceeding 47,000, was granted town status with full rights for self-government. The pre-revolutionary period saw the population of Novosibirsk reach 80,000. During this period the city experienced steady and rapid economic growth, becoming one of the largest commercial and industrial centers of Siberia and developing a significant agricultural processing industry, as well as a power station, iron foundry, commodity market, several banks, and commercial and shipping companies. By 1917, Novosibirsk possessed seven Orthodox churches and one Roman Catholic church, several cinemas, forty primary schools, a high school, a teaching seminary, and the Romanov House non-classical secondary school. In 1913, Novonikolayevsk became one of the first places in Russia to institute compulsory primary education.</p>                
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>
</div>


<div class="test test_arr">
    <div class="test__description">
        Fixable elements + track + bar + controls + pause.
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">The Ob River</h1>
                </div>
                <p class="text">iis a major river in western Siberia, Russia and is the world's seventh longest river. It is the westernmost of the three great Siberian rivers that flow into the Arctic Ocean (the other two being the Yenisei River and the Lena River). The Gulf of Ob is the world's longest estuary.</p>
                <div class="header">
                    <h1 class="header__title">Names</h1>
                </div>
                <p class="text">The Ob is known to the Khanty people as the As, Yag, Kolta and Yema; to the Nenets people as the Kolta or Kuay; and to the Siberian Tatars as the Umar or Omass. Possibly from proto-Indo-Iranian *ap- river, water.</p>


                <div class="header">
                    <h1 class="header__title">Geography</h1>
                </div>
                <p class="text">The Ob forms 16 miles (26 km) southwest of Biysk in Altai Krai at the confluence of the Biya and Katun rivers. Both these streams have their origin in the Altay Mountains, the Biya issuing from Lake Teletskoye, the Katun, 700 kilometres (430 mi) long, bursting out of a glacier on Mount Byelukha.
                <p class="text">The river splits into more than one arm, especially after joining the large Irtysh tributary at about 69° E. (Originating in China, the Irtysh is actually longer than the Ob from source to the point of their confluence.) From the source of the Irtysh to the mouth of the Ob, the river flow is the longest in Russia at 5,410 kilometres (3,360 mi). Other noteworthy tributaries are: from the east, the Tom, Chulym, Ket, Tym and Vakh rivers; and, from the west and south, the Vasyugan, Irtysh (with the Ishim and Tobol rivers), and Sosva rivers.
                <p class="text">The Ob zigzags west and north until it reaches 55° N, where it curves round to the northwest, and again north, wheeling finally eastwards into the Gulf of Ob, a 600-mile (970 km)-long bay of the Kara Sea, separating the Yamal Peninsula from the Gydan Peninsula.
                <p class="text">The combined Ob-Irtysh system, the third-longest river system of Asia (after China's Yangtze and Yellow rivers), is 5,410 kilometres (3,360 mi) long, and the area of its basin 2,990,000 square kilometres (1,150,000 sq mi). The river basin of the Ob consists mostly of steppe, taiga, swamps, tundra, and semi-desert topography. The floodplains of the Ob are characterized by many tributaries and lakes. The Ob is ice-bound at southern Barnaul from early in November to near the end of April, and at northern Salekhard, 100 miles (160 km) above its mouth, from the end of October to the beginning of June. The Ob River crosses several climatic zones. The upper Ob valley, in the south, grows grapes, melons and watermelons, whereas the lower reaches of the Ob are Arctic tundra. The most comfortable climate for the rest on the Ob - are Biysk, Barnaul, and Novosibirsk.
            </div>
            <div class="scroller__track-visual"></div>
            <div class="scroller__track">
                <div class="scroller__bar"></div>
            </div>
            <div class="scroller__control scroller__up">up</div>
            <div class="scroller__control scroller__down">down</div>
        </div>
    </div>
</div>

<div class="test test_arr">
    <div class="test__description">
        The Novosibirsk Zoo
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">The Novosibirsk Zoo</h1>
                </div>
                <p class="text">The Novosibirsk Zoo is a world-renowned scientific institution as well as a popular tourist attraction. The zoo has over four thousand animals and is an active participant of thirty-two different captive breeding programmes for endangered species. On average, around 700,000 people visit the zoo each year.
                <p class="text">In 2000, the zoo held the closest relative to the cape lion of South Africa. John Spence was always fascinated about the stories of these grand lions scaling the walls of General van Riebeeck's castle in the 17th century. Spence's search took thirty years, which led him to the Novosibirsk Zoo, where he found the closest living resemblance to the cape lion; the zoo called the lion Simon. The lion and his family are kept outdoors in large, natural settings. "It is kept all the year around in the climate conditions of the west Siberia at the temperatures from −49 °C (−56 °F) to 36 °C (97 °F). In forty years, more than sixty cubs were born."
                <p class="text">The zoo's current curator is Rostislav Shilo. Simon's cubs were named after him and his wife, Olga.
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>
</div>

<div class="test test_wo-headers">
    <div class="test__description">
        The Novosibirsk Opera and Ballet Theatre
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container">
                <p class="text">The Novosibirsk Opera and Ballet Theatre (the official title being the Novosibirsk State Academic Opera and Ballet Theatre (Russian: Новосибирский государственный академический театр оперы и балета) is one the most important theatres in Novosibirsk and Siberia. It is located at the center of Novosibirsk at Lenin square.
                <p class="text">Building was completed in February 1944, the first performance being held on 12 May 1945. Currently, it is the largest theatre in Russia, larger than the Bolshoi Theatre (literally "Big theatre") in Moscow. After its renovation in 2005 with computerized stage equipment, at the time it became the most technically advanced in Russia. The total area of the building is 11 837 m², the volume is 294 340 m³. The theatre is often called the "Siberian Coliseum" because of its size and beauty. The auditorium seats more than 1,790 spectators. Its upper gallery is decorated with copies of antique Greek statues.
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>
</div>

<div class="test test_negative-viewport">
    <div class="test__description">
        No header fixing because there not enought space for them.
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container">
                <div class="header"><h1 class="header__title">Novosibirsk</h1></div>
                <p class="text">is
                <div class="header"><h1 class="header__title">the</h1></div>
                <p class="text">third-largest
                <div class="header"><h1 class="header__title">city</h1></div>
                <p class="text">in
                <div class="header"><h1 class="header__title">Russia</h1></div>
                <p class="text">(after
                <div class="header"><h1 class="header__title">Moscow</h1></div>
                <p class="text">and
                <div class="header"><h1 class="header__title">St. </h1></div>
                <p class="text">Petersburg
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>
</div>

<div class="test test_flex">
    <div class="test__description">
        Flexible height for bar appearing / disappearing on the fly (try to resize window).
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">Novosibirsk Metro</h1>
                </div>
                <p class="text">The system contains 13 stations on two lines. There are 80 carriages that form 20 four-carriage trains which carry over 250,000 passengers daily. The stations are vividly decorated in late-Soviet style. Currently, of the 13 stations (12 station plus the interchange station counted twice), seven are pillar-trispan, four are single vaults. There is also a surface level station which follows a 2.145 km covered bridge span of the Ob River.</p>
            </div>
            <div class="scroller__bar-wrapper">
                <div class="scroller__bar"></div>
            </div>
        </div>
    </div>
</div>

<div class="test test_flex-headers">
    <div class="test__description">
        Flexible height for bottom fixed headers position change. Change window height and see on bottom headers. Also, see what happen when viewport (white segments between headers) goes to negative height.
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">Novosibirsk State University</h1>
                </div>
                <p class="text">Novosibirsk State University was founded in May 1959 in the USSR by Soviet academicians Mikhail Alekseevich Lavrentiev, Sergei Lvovich Sobolev and Sergey Alekseyevich Khristianovich in a program of establishing a Siberian Division of the USSR Academy of Sciences. Novosibirsk State University is one of the most famous universities in Russia, although is somewhat young. The university is located 20 kilometers from the city of Novosibirsk, a cultural and industrial center of Siberia. The total number of students in the year 1999 was 5200.</p>
                <div class="header">
                    <h1 class="header__title">History</h1>
                </div>
                <p class="text">Three fellow members of the USSR Academy of Sciences Lavrentiev, Sobolev, and Khristianovich, decided to bring international level research over the Urals from Moscow to the vast territories of Siberia. Siberia possessed copious natural resources, but lacked large research institutions which would promote economic development and growth in the region. The idea was implemented with the establishment of the Siberian Division of the USSR Academy of Sciences in 1958 near the large industrial city of Novosibirsk. A new academic town (Akademgorodok) started to grow rapidly and half a year later a new university was founded to train young researchers for the newly born science center.
                <p class="text">Thus, in May 1959 the USSR Higher Education Ministry issued a decree to begin studies in Novosibirsk State University on September 1, 1959 with Ilia N. Vekua as rector (Russian for president or chancellor of a university). The July 20, 1959 issue of the newspaper Pravda reported the opening of the new university and announced admittance with entrance examinations for future students from all over the USSR in the period of August 1 through 20. 139 first-year students were admitted as full-time students and 119 as part-time students. In addition, the best students from other Soviet universities were selected as second-year students. The applicants for chemistry and physics accounted for eight and five persons per vacancy respectively, with three persons for mathematics, mechanics and geology.
                <p class="text">First lectures were held in the building of a secondary school, and first dormitories for the students were just tents amidst the forest; but the spirit of novelty and the lust for education and research created a strong motivation among the first students.
                <p class="text">At first, the only department of the University, the Department of Natural Sciences, combined Mathematics, Physics, Mechanics, Biology,Chemistry and Geology. Between 1960 and 1967 new departments began to separate into their own disciplines. In December, 1963 the first graduates of the Novosibirsk State University, including 26 physicists, 24 mathematicians and ten researchers in mechanics, received diplomas.


                <div class="header">
                    <h1 class="header__title">Education and Research</h1>
                </div>
                <p class="text">The Novosibirsk State University is a coeval and a creation of the Siberian Division of the Academy of Sciences of the USSR. The "Founding Fathers of Siberian Science" believed that it was impossible to organize a scientific center without solving the problem of training young researchers. On the other hand, almost 80% of the Siberian Division staff consists of NSU graduates. Some journalists still argue whether the Siberian Division gave birth to the University or the University built up the Siberian Division.
                <p class="text">In the USSR and subsequently in Russia, universities serve primarily as educational institutions, in which faculty members rarely do research and focus on training students. Research and graduate training exist in separate research institutions. The main idea of the founders of NSU was to combine research and education in the University by inviting scientists from the nearby research institutions in Akademgorodok as part-time university faculty. This allowed students to gain laboratory experience in addition to regular coursework. Additionally, it allowed students to undertake the writing of theses.
                <p class="text">This idea propelled NSU toward becoming arguably one of the best Russian universities. However, this design also led to a number of disadvantages. In official ratings of Russian universities NSU is not near the top. This may be attributed to the fact that the ratings do not consider part-time staff and only account for volumes of the university library, while NSU students also have access to a number of institute libraries as well as the large Academy of Sciences Library which is located across the street from the main University building. Another disadvantage is that NSU trains researchers mainly for the Academy of Sciences; therefore, non-science majors are underrepresented in the University. To attempt to correct this imbalance, Law, Medicine, Foreign Languages, and a few other departments were added recently. However, in conditions of post-perestroika financial crisis in Russian higher education, this innovation has received a great deal of criticism. Critics say that new departments drain money from the science departments from which NSU draws its reputation.
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>
</div>

<div class="test">
    <div class="test__description">
        No js.
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">Novosibirsk history</h1>
                </div>
                <p class="text">During Stalin's industrialization, Novosibirsk secured its place as one of the largest industrial centers of Siberia. Several massive industrial facilities were created in there, including the 'Sibkombain' plant, specializing in the production of heavy mining equipment. Additionally a metal processing plant, a food processing plant and other industrial enterprises and factories were built, as well as a new power station. The Great Soviet Famine saw the influx of more than 170,000 refugees to Novosibirsk. The new arrivals settled in barracks at the outskirts of the city, giving rise to slums such as Bolshaya Nakhalovka, Malaya Nakhalovka, and others.
                <p class="text">Rapid growth and industrialization were the reasons behind Novosibirsk's nickname: the "Chicago of Siberia".
                <p class="text">Tram rails were laid down in 1934, by which time the population had reached 287,000, making Novosibirsk the largest city in Siberia. The following year the original bridge over the Ob River was replaced by the new Kommunalny bridge.
                <p class="text">The rapid growth of the city prompted the construction of a hydroelectric power station with a capacity of 400 megawatts, necessitating the creation of a giant water reservoir, now known as the Ob Sea. As a direct result of the station's construction vast areas of fertile land were flooded as were relic pine woods in the area; additionally, the new open space created by the reservoir's surface caused average wind speeds to double, increasing the rate of soil erosion.
                <p class="text">In the 1950s, the Soviet Government directed that a center for scientific research be built in Novosibirsk; consequently, the multi-facility scientific research complex of Akademgorodok was constructed about 30 kilometers (19 mi) south of the city center in 1957. The Siberian Division of the Academy of Sciences has its headquarters in Akademgorodok, and the town hosts a total of fourteen research institutions and universities. Although it possesses a fully autonomous infrastructure, Akademgorodok is administered by Novosibirsk.
                <p class="text">On September 2, 1962, the population of Novosibirsk reached one million. At that time, it was the youngest city in the world with over a million people. Novosibirsk took fewer than seventy years to achieve this milestone.
                <p class="text">In 1979, work began on the Novosibirsk Metro Transit System, culminating in the opening of the first line in 1985.
                <p class="text">On August 1, 2008, Novosibirsk was in the center of the path of a solar eclipse, with a duration of 2 minutes and 20 seconds.</p>
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>
</div>

<div class="test test_advanced">
    <div class="test__description">
        No jQuery (qwery, bean and bonzo). Try mousewheel in Chrome on header.
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">Climate</h1>
                </div>
                <p class="text">The climate is humid continental (Köppen Dfb), with warm summers and severely cold winters. Snow is frequent, falling on almost half of all winter days, but individual snowfalls are usually light. On average temperatures range in summer from +15 °C (59 °F) to +26 °C (79 °F), in winter from −20 °C (−4 °F) to −12 °C (10 °F). However, winter temperatures can go as low as −30 °C (−22 °F) to −35 °C (−31 °F), and summer temperatures can go as high as +30 °C (86 °F) to +35 °C (95 °F). The difference between the highest and lowest recorded temperatures is 88 °C (158 °F). Most days the weather is sunny, with an average of 2,880 hours of sunshine per year, but heavy rain is possible in summer.
                <p class="text">Travelers coming from countries with mild climates may find Novosibirsk’s winter tough, but it may not be extraordinary for those from northern countries. At times, bitter cold may hold for some days, but temperatures of −40 °C (−40 °F) and lower do not occur every year. In the springtime, streets and roads become dirty as a result of mud and melting snow, while the weather is still cold.
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>
</div>

<div class="test test_horizontal">
    <div class="test__description">
        Horizontal scroll.
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">C l i m a t e</h1>
                </div>
                <p class="text">The climate is humid continental (Köppen Dfb), with warm summers and severely cold winters. Snow is frequent, falling on almost half of all winter days, but individual snowfalls are usually light. On average temperatures range in summer from +15 °C (59 °F) to +26 °C (79 °F), in winter from −20 °C (−4 °F) to −12 °C (10 °F). However, winter temperatures can go as low as −30 °C (−22 °F) to −35 °C (−31 °F), and summer temperatures can go as high as +30 °C (86 °F) to +35 °C (95 °F). The difference between the highest and lowest recorded temperatures is 88 °C (158 °F). Most days the weather is sunny, with an average of 2,880 hours of sunshine per year, but heavy rain is possible in summer.
                <div class="header">
                    <h1 class="header__title">C l i m a t e</h1>
                </div>
                <p class="text">Travelers coming from countries with mild climates may find Novosibirsk’s winter tough, but it may not be extraordinary for those from northern countries. At times, bitter cold may hold for some days, but temperatures of −40 °C (−40 °F) and lower do not occur every year. In the springtime, streets and roads become dirty as a result of mud and melting snow, while the weather is still cold.

            </div>
            <div class="scroller__bar scroller__bar_h"></div>
        </div>
    </div>
</div>

<div class="test test_varheights">
    <div class="test__description">
        The Ob River
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">The Ob River, and this header has variable height</h1>
                </div>
                <p class="text">iis a major river in western Siberia, Russia and is the world's seventh longest river. It is the westernmost of the three great Siberian rivers that flow into the Arctic Ocean (the other two being the Yenisei River and the Lena River). The Gulf of Ob is the world's longest estuary.</p>
                <div class="header">
                    <h1 class="header__title">Names</h1>
                </div>
                <p class="text">The Ob is known to the Khanty people as the As, Yag, Kolta and Yema; to the Nenets people as the Kolta or Kuay; and to the Siberian Tatars as the Umar or Omass. Possibly from proto-Indo-Iranian *ap- river, water.</p>


                <div class="header">
                    <h1 class="header__title">Geography</h1>
                </div>
                <p class="text">The Ob forms 16 miles (26 km) southwest of Biysk in Altai Krai at the confluence of the Biya and Katun rivers. Both these streams have their origin in the Altay Mountains, the Biya issuing from Lake Teletskoye, the Katun, 700 kilometres (430 mi) long, bursting out of a glacier on Mount Byelukha.
                <p class="text">The river splits into more than one arm, especially after joining the large Irtysh tributary at about 69° E. (Originating in China, the Irtysh is actually longer than the Ob from source to the point of their confluence.) From the source of the Irtysh to the mouth of the Ob, the river flow is the longest in Russia at 5,410 kilometres (3,360 mi). Other noteworthy tributaries are: from the east, the Tom, Chulym, Ket, Tym and Vakh rivers; and, from the west and south, the Vasyugan, Irtysh (with the Ishim and Tobol rivers), and Sosva rivers.
                <p class="text">The Ob zigzags west and north until it reaches 55° N, where it curves round to the northwest, and again north, wheeling finally eastwards into the Gulf of Ob, a 600-mile (970 km)-long bay of the Kara Sea, separating the Yamal Peninsula from the Gydan Peninsula.
                <p class="text">The combined Ob-Irtysh system, the third-longest river system of Asia (after China's Yangtze and Yellow rivers), is 5,410 kilometres (3,360 mi) long, and the area of its basin 2,990,000 square kilometres (1,150,000 sq mi). The river basin of the Ob consists mostly of steppe, taiga, swamps, tundra, and semi-desert topography. The floodplains of the Ob are characterized by many tributaries and lakes. The Ob is ice-bound at southern Barnaul from early in November to near the end of April, and at northern Salekhard, 100 miles (160 km) above its mouth, from the end of October to the beginning of June. The Ob River crosses several climatic zones. The upper Ob valley, in the south, grows grapes, melons and watermelons, whereas the lower reaches of the Ob are Arctic tundra. The most comfortable climate for the rest on the Ob - are Biysk, Barnaul, and Novosibirsk.</p>                
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>
</div>

<div class="test test_scroll-height">
    <div class="test__description">
        Container has absolute positioning elements outside and margin collapse.
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container" style="overflow: visible;">
                <div style="margin-top: 1000px; height: 100px; background: red">AAA</div>
                <div class="header">
                    <h1 class="header__title">The Ob River, and this header has variable height</h1>
                </div>
                <p class="text">iis a major river in western Siberia, Russia and is the world's seventh longest river. It is the westernmost of the three great Siberian rivers that flow into the Arctic Ocean (the other two being the Yenisei River and the Lena River). The Gulf of Ob is the world's longest estuary.</p>
                <div class="header">
                    <h1 class="header__title">Names</h1>
                </div>
                <p class="text">The Ob is known to the Khanty people as the As, Yag, Kolta and Yema; to the Nenets people as the Kolta or Kuay; and to the Siberian Tatars as the Umar or Omass. Possibly from proto-Indo-Iranian *ap- river, water.</p>


                <div class="header">
                    <h1 class="header__title">Geography</h1>
                </div>
                <p class="text">The Ob forms 16 miles (26 km) southwest of Biysk in Altai Krai at the confluence of the Biya and Katun rivers. Both these streams have their origin in the Altay Mountains, the Biya issuing from Lake Teletskoye, the Katun, 700 kilometres (430 mi) long, bursting out of a glacier on Mount Byelukha.
                <p class="text">The river splits into more than one arm, especially after joining the large Irtysh tributary at about 69° E. (Originating in China, the Irtysh is actually longer than the Ob from source to the point of their confluence.) From the source of the Irtysh to the mouth of the Ob, the river flow is the longest in Russia at 5,410 kilometres (3,360 mi). Other noteworthy tributaries are: from the east, the Tom, Chulym, Ket, Tym and Vakh rivers; and, from the west and south, the Vasyugan, Irtysh (with the Ishim and Tobol rivers), and Sosva rivers.
                <p class="text">The Ob zigzags west and north until it reaches 55° N, where it curves round to the northwest, and again north, wheeling finally eastwards into the Gulf of Ob, a 600-mile (970 km)-long bay of the Kara Sea, separating the Yamal Peninsula from the Gydan Peninsula.
                <p class="text">The combined Ob-Irtysh system, the third-longest river system of Asia (after China's Yangtze and Yellow rivers), is 5,410 kilometres (3,360 mi) long, and the area of its basin 2,990,000 square kilometres (1,150,000 sq mi). The river basin of the Ob consists mostly of steppe, taiga, swamps, tundra, and semi-desert topography. The floodplains of the Ob are characterized by many tributaries and lakes. The Ob is ice-bound at southern Barnaul from early in November to near the end of April, and at northern Salekhard, 100 miles (160 km) above its mouth, from the end of October to the beginning of June. The Ob River crosses several climatic zones. The upper Ob valley, in the south, grows grapes, melons and watermelons, whereas the lower reaches of the Ob are Arctic tundra. The most comfortable climate for the rest on the Ob - are Biysk, Barnaul, and Novosibirsk.</p>

                <div style="position: relative; height: 10px; background: #ffa">
                    <div style="position: absolute; height: 100px; width: 100%; background: red">ZZZ</div>
                </div>
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>
</div>

<div class="test test_bidir">
    <div class="test__description">
        Bidirectional scroll.
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container" style="width: 800px; height: 400px; background: #fee">
                <p class="text">The Ob forms 16 miles (26 km) southwest of Biysk in Altai Krai at the confluence of the Biya and Katun rivers. Both these streams have their origin in the Altay Mountains, the Biya issuing from Lake Teletskoye, the Katun, 700 kilometres (430 mi) long, bursting out of a glacier on Mount Byelukha.
                <p class="text">The river splits into more than one arm, especially after joining the large Irtysh tributary at about 69° E. (Originating in China, the Irtysh is actually longer than the Ob from source to the point of their confluence.) From the source of the Irtysh to the mouth of the Ob, the river flow is the longest in Russia at 5,410 kilometres (3,360 mi). Other noteworthy tributaries are: from the east, the Tom, Chulym, Ket, Tym and Vakh rivers; and, from the west and south, the Vasyugan, Irtysh (with the Ishim and Tobol rivers), and Sosva rivers.
                <p class="text">The Ob zigzags west and north until it reaches 55° N, where it curves round to the northwest, and again north, wheeling finally eastwards into the Gulf of Ob, a 600-mile (970 km)-long bay of the Kara Sea, separating the Yamal Peninsula from the Gydan Peninsula.
                <p class="text">The combined Ob-Irtysh system, the third-longest river system of Asia (after China's Yangtze and Yellow rivers), is 5,410 kilometres (3,360 mi) long, and the area of its basin 2,990,000 square kilometres (1,150,000 sq mi). The river basin of the Ob consists mostly of steppe, taiga, swamps, tundra, and semi-desert topography. The floodplains of the Ob are characterized by many tributaries and lakes. The Ob is ice-bound at southern Barnaul from early in November to near the end of April, and at northern Salekhard, 100 miles (160 km) above its mouth, from the end of October to the beginning of June. The Ob River crosses several climatic zones. The upper Ob valley, in the south, grows grapes, melons and watermelons, whereas the lower reaches of the Ob are Arctic tundra. The most comfortable climate for the rest on the Ob - are Biysk, Barnaul, and Novosibirsk.</p>
            </div>
            <div class="scroller__bar"></div>
            <div class="scroller__bar scroller__bar_h"></div>
        </div>
    </div>
</div>

<div class="test test_bidir-2">
    <div class="test__description">
        Bidirectional scroll root bug.
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container" style="width: 800px; height: 400px; background: #fee">
                <p class="text">The Ob forms 16 miles (26 km) southwest of Biysk in Altai Krai at the confluence of the Biya and Katun rivers. Both these streams have their origin in the Altay Mountains, the Biya issuing from Lake Teletskoye, the Katun, 700 kilometres (430 mi) long, bursting out of a glacier on Mount Byelukha.
                <p class="text">The river splits into more than one arm, especially after joining the large Irtysh tributary at about 69° E. (Originating in China, the Irtysh is actually longer than the Ob from source to the point of their confluence.) From the source of the Irtysh to the mouth of the Ob, the river flow is the longest in Russia at 5,410 kilometres (3,360 mi). Other noteworthy tributaries are: from the east, the Tom, Chulym, Ket, Tym and Vakh rivers; and, from the west and south, the Vasyugan, Irtysh (with the Ishim and Tobol rivers), and Sosva rivers.
                <p class="text">The Ob zigzags west and north until it reaches 55° N, where it curves round to the northwest, and again north, wheeling finally eastwards into the Gulf of Ob, a 600-mile (970 km)-long bay of the Kara Sea, separating the Yamal Peninsula from the Gydan Peninsula.
                <p class="text">The combined Ob-Irtysh system, the third-longest river system of Asia (after China's Yangtze and Yellow rivers), is 5,410 kilometres (3,360 mi) long, and the area of its basin 2,990,000 square kilometres (1,150,000 sq mi). The river basin of the Ob consists mostly of steppe, taiga, swamps, tundra, and semi-desert topography. The floodplains of the Ob are characterized by many tributaries and lakes. The Ob is ice-bound at southern Barnaul from early in November to near the end of April, and at northern Salekhard, 100 miles (160 km) above its mouth, from the end of October to the beginning of June. The Ob River crosses several climatic zones. The upper Ob valley, in the south, grows grapes, melons and watermelons, whereas the lower reaches of the Ob are Arctic tundra. The most comfortable climate for the rest on the Ob - are Biysk, Barnaul, and Novosibirsk.</p>
            </div>
            <div class="scroller__bar"></div>
            <div class="scroller__bar scroller__bar_h"></div>
        </div>
    </div>
</div>

<div class="test test_textarea">
    <div class="test__description">
        Bidirectional scroll on textarea.
    </div>
    <div class="wrapper">
        <textarea class="scroller" style="font-size: 4000px; line-height: 100px">-</textarea>
        <div class="scroller__track">
            <div class="scroller__bar"></div>
        </div>
        
        <div class="scroller__track_h">
            <div class="scroller__bar scroller__bar_h"></div>
        </div>
    </div>
</div>

<div class="test test_bar-outside" style="position: relative">
    <div class="test__description">
        Bar outside scroller
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container" style="width: 700px;">
                <p class="text">The Ob forms 16 miles (26 km) southwest of Biysk in Altai Krai at the confluence of the Biya and Katun rivers. Both these streams have their origin in the Altay Mountains, the Biya issuing from Lake Teletskoye, the Katun, 700 kilometres (430 mi) long, bursting out of a glacier on Mount Byelukha.
                <p class="text">The river splits into more than one arm, especially after joining the large Irtysh tributary at about 69° E. (Originating in China, the Irtysh is actually longer than the Ob from source to the point of their confluence.) From the source of the Irtysh to the mouth of the Ob, the river flow is the longest in Russia at 5,410 kilometres (3,360 mi). Other noteworthy tributaries are: from the east, the Tom, Chulym, Ket, Tym and Vakh rivers; and, from the west and south, the Vasyugan, Irtysh (with the Ishim and Tobol rivers), and Sosva rivers.
                <p class="text">The Ob zigzags west and north until it reaches 55° N, where it curves round to the northwest, and again north, wheeling finally eastwards into the Gulf of Ob, a 600-mile (970 km)-long bay of the Kara Sea, separating the Yamal Peninsula from the Gydan Peninsula.
                <p class="text">The combined Ob-Irtysh system, the third-longest river system of Asia (after China's Yangtze and Yellow rivers), is 5,410 kilometres (3,360 mi) long, and the area of its basin 2,990,000 square kilometres (1,150,000 sq mi). The river basin of the Ob consists mostly of steppe, taiga, swamps, tundra, and semi-desert topography. The floodplains of the Ob are characterized by many tributaries and lakes. The Ob is ice-bound at southern Barnaul from early in November to near the end of April, and at northern Salekhard, 100 miles (160 km) above its mouth, from the end of October to the beginning of June. The Ob River crosses several climatic zones. The upper Ob valley, in the south, grows grapes, melons and watermelons, whereas the lower reaches of the Ob are Arctic tundra. The most comfortable climate for the rest on the Ob - are Biysk, Barnaul, and Novosibirsk.</p>
            </div>
        </div>
    </div>
    <div class="scroller__track-visual"></div>
    <div class="scroller__track">
        <div class="scroller__bar"></div>
    </div>

    <div class="scroller__track_h">
        <div class="scroller__bar scroller__bar_h"></div>
    </div>
</div>

<div class="test test_mem-leak">
    <div class="test__description">
        Memory leak & dispose method (should not work)
    </div>
    <div class="wrapper">
        <div class="scroller">
            <div class="container">
                <div class="header">
                    <h1 class="header__title">Climate</h1>
                </div>
                <p class="text">is the third most populous city in Russia after Moscow and St. Petersburg and the most populous city in Asian Russia, with a population of 1,473,754 (2010 Census). It is the administrative center of Novosibirsk Oblast as well as of Siberian Federal District. The city is located in the southwestern part of Siberia at the banks of the Ob River and occupies an area of 502.1 square kilometers (193.9 sq mi).</p>
                <div class="header">
                    <h1 class="header__title">History</h1>
                </div>
                <p class="text">Novosibirsk, founded in 1893 at the future site of a Trans-Siberian Railway bridge crossing the great Siberian river of Ob, first received the name Novonikolayevsk (Новониколаевск), in honor both of Saint Nicholas and of the reigning Tsar Nicholas II. The bridge was completed in the spring of 1897, making the new settlement the regional transport hub. The importance of the city further increased with the completion of the Turkestan-Siberia Railway in the early 20th century. The new railway connected Novosibirsk to Central Asia and the Caspian Sea.</p>


                <div class="header">
                    <h1 class="header__title">At the time...</h1>
                </div>
                <p class="text">...of the bridge's opening, Novonikolayevsk hosted a population of 7,800 people. Its first bank opened in 1906, with a total of five banks operating by 1915. In 1907, Novonikolayevsk, now with a population exceeding 47,000, was granted town status with full rights for self-government. The pre-revolutionary period saw the population of Novosibirsk reach 80,000. During this period the city experienced steady and rapid economic growth, becoming one of the largest commercial and industrial centers of Siberia and developing a significant agricultural processing industry, as well as a power station, iron foundry, commodity market, several banks, and commercial and shipping companies. By 1917, Novosibirsk possessed seven Orthodox churches and one Roman Catholic church, several cinemas, forty primary schools, a high school, a teaching seminary, and the Romanov House non-classical secondary school. In 1913, Novonikolayevsk became one of the first places in Russia to institute compulsory primary education.</p>                
            </div>
            <div class="scroller__bar"></div>
        </div>
    </div>
</div>

</body>

</html>

================================================
FILE: vendors/baron/test/script.js
================================================
var b;

$(document).ready(function() {
    var i;

    b = $('.wrapper_very-simple .scroller').baron();

    b.update();

    // Simple initialization with minimum parameters, but with headers
    for (i = 0 ; i < 100 ; i++) {
        $('.wrapper_simple .scroller').baron({
            barOnCls: 'baron'
        }).fix({
            elements: '.header__title',
            outside: 'header__title_state_fixed',
            radius: 30
        });
    }

    // Array initialization + limiter
    $('.test_arr .scroller').baron({
        bar: '.scroller__bar',
        //track: '.scroller__track',
        barOnCls: 'baron',
        pause: 0.1
    }).fix({
        elements: '.header__title',
        outside: 'header__title_state_fixed',
        before: 'header__title_position_top',
        after: 'header__title_position_bottom',
        limiter: true
    })
    .test()
    .controls({
        track: '.scroller__track-visual',
        forward: '.scroller__up',
        backward: '.scroller__down',
        screen: 0.5,
        delta: 60
    });

    // Init without headers
    $('.test_wo-headers .scroller').baron({
        bar: '.scroller__bar',
        barOnCls: 'baron'
    });

    // // Negative viewport
    $('.test_negative-viewport .scroller').baron({
        bar: '.scroller__bar',
        barOnCls: 'baron'
    });

    // Flexible height
    baron({
        scroller: '.test_flex .scroller',
        bar: '.scroller__bar',
        barOnCls: 'baron',
        track: '.scroller__bar-wrapper',
        pause: 0.2
    });

    // Not enought input params
    //baron();

    var babaron = baron.noConflict(),
        anotherBaron = babaron;
    console.log('Original baron value is: ', baron);

    // Flexible height for bottom fixed headers -> they should change positions when window resize occurs.
    anotherBaron({
        scroller: '.test_flex-headers .scroller',
        bar: '.scroller__bar',
        barOnCls: 'baron'
    }).fix({
        elements: '.header__title',
        outside: 'header__title_state_fixed',
        minView: 100
    });

    // No js .test__no-js

    // Maximum variables
    for (i = 0 ; i < 10 ; i++) {
        anotherBaron({
            scroller: '.test_advanced .scroller',
            bar: '.scroller__bar',
            barOnCls: 'baron',
            $: function(selector, context) {
                return bonzo(qwery(selector, context));
            },
            event: function(elem, event, func, mode) { // Events manager
                if (mode == 'trigger') {
                    mode = 'fire';
                }

                bean[mode || 'on'](elem, event, func);
            }
        }).fix({
            elements: '.header__title',
            outside: 'header__title_state_fixed'
        });
    }

    // Variable header 
    anotherBaron({
        scroller: '.test_varheights .scroller',
        bar: '.scroller__bar',
        barOnCls: 'baron'
    }).fix({
        elements: '.header__title',
        outside: 'header__title_state_fixed',
        minView: 100
    });

    // Elements outside container
    anotherBaron({
        scroller: '.test_scroll-height .scroller',
        bar: '.scroller__bar',
        barOnCls: 'baron'
    }).fix({
        elements: '.header__title',
        outside: 'header__title_state_fixed',
        minView: 100
    });

    // Horizontal scroll
    $('.test_horizontal .scroller').baron({
        bar: '.scroller__bar',
        barOnCls: 'baron',
        direction: 'h'
    }).fix({
        elements: '.header__title',
        outside: 'header__title_state_fixed',
        before: 'before',
        after: 'after',
        limiter: true
    });

    // Bidirectional scroll
    $('.test_bidir .scroller').baron({
        bar: '.scroller__bar',
        barOnCls: 'baron'
    }).baron({
        bar: '.scroller__bar_h',
        barOnCls: 'baron_h'
    });

    // Bidirectional scroll root bug
    anotherBaron({
        scroller: '.test_bidir-2 .scroller',
        bar: '.scroller__bar',
        barOnCls: 'baron'
    }).baron({
        bar: '.scroller__bar_h',
        barOnCls: 'baron_h'
    });

    // Textarea scroll
    $('.test_textarea').baron({
        scroller: '.scroller',
        bar: '.scroller__bar',
        barOnCls: 'baron'
    }).baron({
        bar: '.scroller__bar_h',
        barOnCls: 'baron_h'
    });

    // Bar outside
    $('.test_bar-outside').baron({
        scroller: '.scroller',
        bar: '.scroller__bar',
        barOnCls: 'baron'
    }).baron({
        bar: '.scroller__bar_h',
        barOnCls: 'baron_h'
    });

    var leak = [];
    for (i = 0 ; i < 1000 ; i++) {
        $('.test_mem-leak').attr('data-baron-v', '');
        var l = $('.test_mem-leak').baron({
            scroller: '.scroller',
            bar: '.scroller__bar',
            barOnCls: 'baron'
        });
        leak.push(l);
        l.dispose();
    }
});

================================================
FILE: vendors/baron/test/style.css
================================================
html, body {height: 100%;margin: 0; padding: 0; font-family: Verdana;}

.test {
    z-index: 0;
    width: 30%;
    height: 400px;
    display: inline-block;
    background: #eee;
    margin: 5px;
    box-shadow: 0 0 4px #ccc;
    vertical-align: top;
}

.test_flex {
    height: 40%;
}
.test_flex .wrapper {
    height: 70%;
}
.test_flex-headers {
    height: 40%;
}
.test_flex-headers .wrapper {
    height: 70%;
}

.wrapper {
    position: relative;
    z-index: 1;
    overflow: hidden;
    height: 200px;
    margin: 1px auto;
    background: #fff;
    border: 1px solid #fc9;
    box-shadow:
        0 5px 15px -3px rgba(0, 0, 0, .7),
        0 0 0 1px rgba(0, 0, 0, .05);
}
.scroller {
    height: 100%;
    overflow: auto;
}
.scroller::-webkit-scrollbar {
    width: 0;
    height: 0;
}
.scroller__bar-wrapper {
    display: none;
    position: absolute;
    z-index: 1;
    top: 10px;
    bottom: 10px;
    right: 5px;
    width: 8px;
    border-radius: 5px;
    background: #ddf;
    background: rgba(0, 0, 255, .1);
}
.scroller__track {
    position: absolute;
    z-index: 3;
    top: 0;
    right: 0;
    bottom: 0;
}
.scroller__track-visual {
    position: absolute;
    z-index: 2;
    top: 0;
    right: 0;
    bottom: 0;
    width: 10px;
    background: rgba(255, 100, 100, .2);
}
.scroller__track-visual:active {
    box-shadow: 0 0 7px rgba(0, 0, 0, .4) inset;
}
.scroller__track_h {
    left: 0;
    bottom: auto;
    width: auto;
}
.scroller__bar {
    position: absolute;
    z-index: 1;
    display: none;
    width: 8px;
    border-radius: 3px;
    background: #987;
    opacity: .6;
    -webkit-transition: width .2s linear;
    transition: width .2s linear;
}
.wrapper_very-simple .scroller__bar {
    display: block;
}
.scroller__bar:hover {
    opacity: .8;
}
.baron .scroller__bar {
    display: block;
}
.hbaron .scroller__bar_h {
    display: block;
}
.baron .scroller__bar-wrapper {
    display: block;
}

.container {
    overflow: hidden;
}

.header {
    /*height: 20px;*/
}
.header__title {
    width: 100%;
    /*height: 20px;*/
    -moz-box-sizing: border-box;
    box-sizing: border-box;
    background: #ebe7e4;
    background-color: rgba(200, 255, 250, 1);
    box-shadow: 0 -1px 0 rgba(0, 0, 0, .05);
    color: #222;
    font-size: 14px;
    opacity: 1;
}
.header__title_state_fixed {
    position: absolute;
    z-index: 1;
    background-color: rgba(220, 229, 250, .6);
    text-shadow: 0 0 5px #fff;
}
.header__title_position_top {
    background: rgba(255, 229, 250, .6);
}
.header__title_position_bottom {
    background: rgba(220, 255, 250, .6);
}
.header__title_group_top {
    color: red;
}
.header__title_group_bottom {
    color: green;
}

.text {
    overflow: hidden;
    margin: 10px;
    font-size: 12px;
}


.test_horizontal .scroller {
    height: 100%;
    width: auto;
    overflow-x: scroll;
    overflow-y: hidden;
    white-space: nowrap;
}
.test_horizontal .container {
    display: inline-block;
    height: 100%;
}
.test_horizontal .header {
    height: 100%;
    display: inline-block;
    white-space: normal;
    vertical-align: top;
}
.test_horizontal .text {
    display: inline-block;
    white-space: normal;
    vertical-align: top;
    width: 800px;
}
.test_horizontal .header__title {
    width: 20px;
    height: 100%;
}

.test_textarea .scroller__bar {
    display: block;
}

/* Controls */
.scroller__control {
    position: absolute;
    z-index: 4;
    width: 20px;
    height: 20px;
    background: #fc9;
    cursor: pointer;
    -webkit-user-select: none;
    -moz-user-select: none;
    user-select: none;
}
.scroller__up {
    top: 0;
    right: 0;
}
.scroller__down {
    bottom: 0;
    right: 0;
}

.scroller__pull {
    background: red;
}

================================================
FILE: vendors/baron/test/tests.js
================================================
var barOnCls = 'baron';

var originalHTML = '<div class="scroller"><div class="container"><div class="header"><h1 class="header__title">Baron</h1></div><p class="text">is the third most populous city in Russia after Moscow and St. Petersburg and the most populous city in Asian Russia, with a population of 1,473,754 (2010 Census). It is the administrative center of Novosibirsk Oblast as well as of Siberian Federal District. The city is located in the southwestern part of Siberia at the banks of the Ob River and occupies an area of 502.1 square kilometers (193.9 sq mi).</p><div class="header"><h1 class="header__title">Baron</h1></div><p class="text">Novosibirsk, founded in 1893 at the future site of a Trans-Siberian Railway bridge crossing the great Siberian river of Ob, first received the name Novonikolayevsk (Новониколаевск), in honor both of Saint Nicholas and of the reigning Tsar Nicholas II. The bridge was completed in the spring of 1897, making the new settlement the regional transport hub. The importance of the city further increased with the completion of the Turkestan-Siberia Railway in the early 20th century. The new railway connected Novosibirsk to Central Asia and the Caspian Sea.</p><div class="header"><h1 class="header__title">Baron</h1></div><p class="text">...of the bridges opening, Novonikolayevsk hosted a population of 7,800 people. Its first bank opened in 1906, with a total of five banks operating by 1915. In 1907, Novonikolayevsk, now with a population exceeding 47,000, was granted town status with full rights for self-government. The pre-revolutionary period saw the population of Novosibirsk reach 80,000. During this period the city experienced steady and rapid economic growth, becoming one of the largest commercial and industrial centers of Siberia and developing a significant agricultural processing industry, as well as a power station, iron foundry, commodity market, several banks, and commercial and shipping companies. By 1917, Novosibirsk possessed seven Orthodox churches and one Roman Catholic church, several cinemas, forty primary schools, a high school, a teaching seminary, and the Romanov House non-classical secondary school. In 1913, Novonikolayevsk became one of the first places in Russia to institute compulsory primary education.</p><div class="header"><h1 class="header__title">Baron</h1></div></div><div class="scroller__bar"></div></div>';

function eachIt(baron) {
    it("Возвращает барон-объект", function() {
        assert.ok(baron);
        assert.ok(baron.update);
        assert.ok(baron.dispose);
    });
}

describe("Барон.", function() {
    describe("Успешная инициализация барона по-умолчанию", function() {
        var baron,
            scroller,
            bar;

        before(function() {
            baron = $('.scroller').baron({
                bar: '.scroller__bar',
                barOnCls: barOnCls
            });

            scroller = $('.scroller')[0];
            bar = $('.scroller__bar')[0];

            eachIt(baron);
        });

        it("Выставляет аттрибут data-baron-v в значение inited", function() {
            var attrV = $('.scroller').attr('data-baron-v'),
                attrH = $('.scroller').attr('data-baron-h');

            assert.ok(attrV == 'inited');
            assert.ok(!attrH);
        });

        it("Находит bar и выставляет ему правильную высоту", function() {
            var height = parseInt($(bar).css('height'), 10),
                expectedHeight = Math.round(scroller.clientHeight * scroller.clientHeight / scroller.scrollHeight);

            assert.ok(baron[0].bar === bar);
            assert.ok(Math.abs(height - expectedHeight) <= 1);
        });

        it("После вызова метода dispose удаляет атрибуты и классы", function() {
            var sizeDim = baron[0].origin.crossSize;

            baron.dispose();

            var attrV = $('.scroller').attr('data-baron-v'),
                attrH = $('.scroller').attr('data-baron-h'),
                cls = $('.scroller').hasClass(barOnCls),
                size = $('.scroller')[0].style[sizeDim];

            //$('.scroller').css(sizeDim)

            assert.ok(!attrV);
            assert.ok(!attrH);
            assert.ok(!cls);
            assert.ok(!size);
        });
    });
});

describe("Плагин fix.", function() {
    describe("Base.", function() {
        var baron,
            scroller,
            scrollTop;

        before(function() {
            scroller = $('.scroller')[0];
        });

        it("No elements", function() {
            $(scroller).find('.header').empty();

            baron = $('.scroller').baron({
                bar: '.scroller__bar',
                barOnCls: barOnCls
            }).fix({
                elements: '.header__title',
                outside: 'header__title_state_fixed',
                before: 'header__title_position_top',
                after: 'header__title_position_bottom',
                clickable: true,
                scroll: function(data) {
                    scrollTop = data.x2;
                }
            });

            $('.wrapper').html(originalHTML);
        });

        it("past and future params", function() {
            baron = $('.scroller').baron({
                bar: '.scroller__bar',
                barOnCls: barOnCls
            }).fix({
                elements: '.header__title',
                outside: 'header__title_state_fixed',
                before: 'header__title_position_top',
                after: 'header__title_position_bottom',
                past: 'header__title_group_top',
                future: 'header__title_group_bottom',
                clickable: true,
                scroll: function(data) {
                    scrollTop = data.x2;
                }
            });

            $('.scroller')[0].scrollTop = 4;
            baron.update(); // Событие выстреливает позже

            var firstHeader = $('.wrapper_headers .scroller .header__title').eq(0),
                secondHeader = $('.wrapper_headers .scroller .header__title').eq(1),
                thirdHeader = $('.wrapper_headers .scroller .header__title').eq(2);

            assert(firstHeader.hasClass('header__title_state_fixed'), '1 outside class');
            assert(firstHeader.hasClass('header__title_position_top'), '1 before class');
            assert(firstHeader.hasClass('header__title_group_top'), '1 past class');

            assert(secondHeader.hasClass('header__title_state_fixed'), '2 outside class');
            assert(secondHeader.hasClass('header__title_position_bottom'), '2 after class');
            assert(secondHeader.hasClass('header__title_group_bottom'), '2 past class');

            assert(thirdHeader.hasClass('header__title_state_fixed'), '3 outside class');
            assert(!thirdHeader.hasClass('header__title_position_bottom'), '3 !after class');
            assert(thirdHeader.hasClass('header__title_group_bottom'), '3 past class');

            baron.dispose();
        });

        it("no future and after classes when bottom edge reached", function() {
            $('.wrapper').html(originalHTML);

            baron = $('.scroller').baron({
                bar: '.scroller__bar',
                barOnCls: barOnCls
            }).fix({
                elements: '.header__title',
                outside: 'header__title_state_fixed',
                before: 'header__title_position_top',
                after: 'header__title_position_bottom',
                past: 'header__title_group_top',
                future: 'header__title_group_bottom',
                clickable: true,
                scroll: function(data) {
                    scrollTop = data.x2;
                }
            });

            $('.scroller')[0].scrollTop = 99999;
            baron.update(); // Событие выстреливает позже

            assert(!$('.wrapper_headers .scroller .header__title').hasClass('header__title_group_bottom'), 'no future class');
            assert(!$('.wrapper_headers .scroller .header__title').hasClass('header__title_position_bottom'), 'no after class');

            // $('.wrapper').html(originalHTML);
        });
    });

    describe("clickable", function() {
        var baron,
            scroller;

        before(function() {
            $('.wrapper').html(originalHTML);

            baron = $('.scroller').baron({
                bar: '.scroller__bar',
                barOnCls: barOnCls
            }).fix({
                elements: '.header__title',
                outside: 'header__title_state_fixed',
                before: 'header__title_position_top',
                after: 'header__title_position_bottom',
                clickable: true
            });

            scroller = $('.scroller')[0];

            eachIt(baron);
        });

        it("Клики по второму заголовку скроллит контент", function() {
            var e = jQuery.Event('click'),
                firstTitle = $('.header__title')[0],
                secondTitle = $('.header__title')[1],
                top = secondTitle.parentNode.offsetTop - firstTitle.parentNode.offsetHeight;

            scroller.scrollTop = 0;
            $(secondTitle).trigger(e);
            assert(scroller.scrollTop == top, 'Проскроллились до уровня ' + scroller.scrollTop + ' при ожидаемом ' + top);
        });

        it("Клики по третьему заголовку", function() {
            var e = jQuery.Event('click'),
                currentTitle = $('.header__title')[2],
                top = currentTitle.parentNode.offsetTop - $('.header__title')[0].parentNode.offsetHeight - $('.header__title')[1].parentNode.offsetHeight;

            $(currentTitle).trigger(e);
            assert(scroller.scrollTop == top, 'Проскроллились до уровня ' + scroller.scrollTop + ' при ожидаемом ' + top);
        });

        it("Клики по первому заголовку", function() {
            var e = jQuery.Event('click'),
                firstTitle = $('.header__title')[0];

            $(firstTitle).trigger(e);
            assert(scroller.scrollTop == 0, 'Проскроллились до уровня ' + scroller.scrollTop + ' при ожидаемом ' + 0);
        });

        it("Клики по четвертому - новому (appended) заголовку", function() {
            var html = '<div class="header"><h1 class="header__title">New header</h1></div><p class="text">...of the bridges opening, Novonikolayevsk hosted a population of 7,800 people. Its first bank opened in 1906, with a total of five banks operating by 1915. In 1907, Novonikolayevsk, now with a population exceeding 47,000, was granted town status with full rights for self-government. The pre-revolutionary period saw the population of Novosibirsk reach 80,000. During this period the city experienced steady and rapid economic growth, becoming one of the largest commercial and industrial centers of Siberia and developing a significant agricultural processing industry, as well as a power station, iron foundry, commodity market, several banks, and commercial and shipping companies. By 1917, Novosibirsk possessed seven Orthodox churches and one Roman Catholic church, several cinemas, forty primary schools, a high school, a teaching seminary, and the Romanov House non-classical secondary school. In 1913, Novonikolayevsk became one of the first places in Russia to institute compulsory primary education.</p>';

            $(scroller).append(html);
            baron.update();

            var e = jQuery.Event('click'),
                currentTitle = $('.header__title')[3],
                top = currentTitle.parentNode.offsetTop - $('.header__title')[0].parentNode.offsetHeight - $('.header__title')[1].parentNode.offsetHeight - $('.header__title')[2].parentNode.offsetHeight;

            $(currentTitle).trigger(e);
            assert(scroller.scrollTop == top, 'Проскроллились до уровня ' + scroller.scrollTop + ' при ожидаемом ' + top);
        });

        after(function() {
            baron.dispose();
        });
    });

    describe("clickable + scroll callback", function() {
        var baron,
            scroller,
            scrollTop;

        before(function() {
            scroller = $('.scroller')[0];

            baron = $('.scroller').baron({
                bar: '.scroller__bar',
                barOnCls: barOnCls
            }).fix({
                elements: '.header__title',
                outside: 'header__title_state_fixed',
                before: 'header__title_position_top',
                after: 'header__title_position_bottom',
                clickable: true,
                scroll: function(data) {
                    scrollTop = data.x2;
                }
            });

            eachIt(baron);
        });

        it("Клики по второму заголовку вызывает callback с правильной координатой", function() {
            var e = jQuery.Event('click'),
                firstTitle = $('.header__title')[0],
                secondTitle = $('.header__title')[1],
                top = secondTitle.parentNode.offsetTop - firstTitle.parentNode.offsetHeight;

            scroller.scrollTop = 0;
            $(secondTitle).trigger(e);
            assert(scrollTop == top, 'Попросили проскроллить до уровня ' + scrollTop + ' при ожидаемом ' + top);
        });

        after(function() {
            baron.dispose();
        });
    });

    describe("Negative margins.", function() {
        var baron,
            scroller;

        before(function() {
            var html = '<div class="scroller"><div class="container"><div class="header"><h1 class="header__title">Baron</h1></div><p class="text">is the third most populous city in Russia after Moscow and St. Petersburg and the most populous city in Asian Russia, with a population of 1,473,754 (2010 Census). It is the administrative center of Novosibirsk Oblast as well as of Siberian Federal District. The city is located in the southwestern part of Siberia at the banks of the Ob River and occupies an area of 502.1 square kilometers (193.9 sq mi).</p><div class="header"><h1 class="header__title">Baron</h1></div><div class="scroller__pull"></div></div><div class="scroller__bar"></div></div>';
            $('.wrapper').html(html);
            $('.header__title').css({margin: '-7px 0 0'});

            scroller = $('.scroller')[0];

            baron = $('.scroller').baron({
                bar: '.scroller__bar',
                barOnCls: barOnCls
            }).fix({
                elements: '.header__title',
                outside: 'header__title_state_fixed',
                before: 'header__title_position_top',
                after: 'header__title_position_bottom'
            });

            eachIt(baron);
        });

        it("No fix classes on first header at start", function() {
            assert(!$('.header__title').eq(0).hasClass('header__title_state_fixed'), 'no fix cls');
            assert(!$('.header__title').eq(0).hasClass('header__title_position_top'), 'no before cls');
            assert(!$('.header__title').eq(0).hasClass('header__title_position_bottom'), 'no after cls');
        });

        it("offsetTop", function() {
            assert($('.header__title')[0].offsetTop == -7, 'offsetTop at start pos ' + $('.header__title')[0].offsetTop);
            $('.scroller')[0].scrollTop = 1;
            baron.update();
            assert($('.header__title')[0].offsetTop == -7, 'offsetTop at 1px scroll ' + $('.header__title')[0].offsetTop);
        });

        after(function() {
            baron.dispose();
        });
    });

    describe("Live params update.", function() {
        var baron,
            scroller;

        before(function() {
            var html = '<div class="scroller"><div class="container"><div class="header"><h1 class="header__title">Baron</h1></div><p class="text">is the third most populous city in Russia after Moscow and St. Petersburg and the most populous city in Asian Russia, with a population of 1,473,754 (2010 Census). It is the administrative center of Novosibirsk Oblast as well as of Siberian Federal District. The city is located in the southwestern part of Siberia at the banks of the Ob River and occupies an area of 502.1 square kilometers (193.9 sq mi).</p><div class="header"><h1 class="header__title">Baron</h1></div><div class="scroller__pull"></div></div><div class="scroller__bar"></div></div>';
            
            $('.wrapper').html(html);

            scroller = $('.scroller')[0];

            baron = $('.scroller').baron({
                bar: '.scroller__bar',
                barOnCls: barOnCls
            }).fix({
                elements: '.header__title',
                outside: 'header__title_state_fixed',
                before: 'header__title_position_top',
                after: 'header__title_position_bottom'
            });

            eachIt(baron);
        });

        it("Add limiter param", function() {
            baron.update({
                fix: {
                    limiter: true
                }
            });
            scroller.scrollTop = 1;
            scroller.scrollTop = 0;

            assert(parseInt($('.scroller__bar').css('top'), 10) == $('.header').height(), 'Самое высокое положение скроллбара теперь ограничено высотой заголовка');

            baron.update({
                fix: {
                    limiter: false
                }
            });
            scroller.scrollTop = 1;
            scroller.scrollTop = 0;
            
            assert(parseInt($('.scroller__bar').css('top'), 10) == 0, 'Самое высокое положение скроллбара снова неограничено высотой заголовка');
        });

        // it("offsetTop", function() {
        //     assert($('.header__title')[0].offsetTop == -7, 'offsetTop at start pos ' + $('.header__title')[0].offsetTop);
        //     $('.scroller')[0].scrollTop = 1;
        //     baron.update();
        //     assert($('.header__title')[0].offsetTop == -7, 'offsetTop at 1px scroll ' + $('.header__title')[0].offsetTop);
        // });

        after(function() {
            baron.dispose();
        });
    });

    describe("Two independed fix.", function() {
        var baron,
            scroller;

        before(function() {
            var html = '<div class="scroller"><div class="container"><div class="header"><h1 class="header__title">Baron</h1></div><p class="text">is the third most populous city in Russia after Moscow and St. Petersburg and the most populous city in Asian Russia, with a population of 1,473,754 (2010 Census). It is the administrative center of Novosibirsk Oblast as well as of Siberian Federal District. The city is located in the southwestern part of Siberia at the banks of the Ob River and occupies an area of 502.1 square kilometers (193.9 sq mi).</p><div class="header"><h1 class="header__title">Baron</h1></div><div class="scroller__pull"></div></div><div class="scroller__bar"></div></div>';
            
            $('.wrapper').html(html);

            scroller = $('.scroller')[0];
            $('.header__title').eq(1).css({height: '100px'});

            baron = $('.scroller').baron({
                bar: '.scroller__bar',
                barOnCls: barOnCls
            }).fix({
                elements: $('.header__title').eq(0),
                outside: 'header__title_state_fixed',
                before: 'header__title_position_top',
                after: 'header__title_position_bottom',
                limiter: true
            }).fix({
                elements: $('.header__title').eq(1),
                outside: 'header__title_state_fixed',
                before: 'header__title_position_top',
                after: 'header__title_position_bottom'
            });

            eachIt(baron);
        });

        it("Bar limited by first header", function() {
            baron.update();
            assert(parseInt($('.scroller__bar').css('top'), 10) == $('.header').height(), 'Самое высокое положение скроллбара ограничено высотой первого заголовка');
        });

        // it("offsetTop", function() {
        //     assert($('.header__title')[0].offsetTop == -7, 'offsetTop at start pos ' + $('.header__title')[0].offsetTop);
        //     $('.scroller')[0].scrollTop = 1;
        //     baron.update();
        //     assert($('.header__title')[0].offsetTop == -7, 'offsetTop at 1px scroll ' + $('.header__title')[0].offsetTop);
        // });

        after(function() {
            baron.dispose();
            $('.header__title').eq(1).css({height: ''});
        });
    });
});













================================================
FILE: vendors/firmcard/doc/Schedule.md
================================================
### Цель

Облегчить работу пользователей с информацией о времени работы организаций.&nbsp;

### Упрощение способа отображения времени работы

Сегодня мы отображаем время работы в виде таблицы. Такая форма отображения избыточна для наиболее распространённых расписаний организаций: когда&nbsp;организации&nbsp;имеют одинаковый график во все рабочие дни без обеда и фиксированные выходные.&nbsp;

Примеры:&nbsp;

![](./img/schedule-table.png "График работы в виде таблицы")

##### Правила отображения в кратком ("свёрнутом") виде

1.  Для случая, когда организация имеет одинаковый график во все дни недели без обеда: пишем "Ежедневно [время работы]", время работы не раскрывается по клику.&nbsp;

&nbsp;![](./img/everyday.png "Ежедневно")

&nbsp; &nbsp; &nbsp;2. Если организация работает круглосуточно: показываем строку "работает круглосуточно", время работы не&nbsp;раскрывается&nbsp;по клику.

![](./img/24x7.png "Круглосуточно")

&nbsp; &nbsp; &nbsp;3. Если организация работает по разному расписанию в разные дни, имеет перерывы на обед или выходные &nbsp;- время работы раскрывается по клику.

&nbsp; &nbsp; &nbsp;![](./img/today-dropdown.png "Сегодня,-раскрывающийся-список")

&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;3.1. Если у организации сегодня есть обед - говорим об этом в свёрнутом виде.

&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;![](./img/today-dinner.png "Сегодня,-обед")

&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;3.2. Если у организации сегодня выходной.

&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;![](./img/holiday.png "Сегодня выходной")

##### Правила отображения полного ("развёрнутого") вида

&nbsp; &nbsp;По данным новосибирского каталога (общее кол-во фирм - 51 255):

&nbsp; &nbsp; &nbsp; компаний, работающих ежедневно по одному графику -&nbsp;15 203 (29,66%)

&nbsp; &nbsp; &nbsp; компаний, имеющих не более трёх интервалов работы (пн-пт, сб, вс) - 49 923 (95,45%)

&nbsp; &nbsp; &nbsp;&nbsp;компании, имеющих обеденный перерыв - 4 554 (8,88%)

&nbsp; &nbsp;В развернутом виде заменяем табличное представление на строчное, для случаев &nbsp;когда у организации два или три интервала работы:

![](./img/schedule-strings.png)

&nbsp; При форматировании строчного представления используем следующие правила

&nbsp; &nbsp; 1. Если время работы одинаково с понедельника по пятницу - оформляем строкой "Будние дни"

&nbsp; &nbsp; 2. Если время работы одинаково, для двух дней подрят - оформляем строкой с перечислением каждого дня "понедельник, вторник"

&nbsp; &nbsp; 3. Если время работы одинаково для трёх и более дней - оформляем периодом "пятница - среда"

&nbsp; &nbsp; 4. Каждая группа должна начинаться с новой строки.&nbsp;

&nbsp; &nbsp;Несмотря на то, что компаний с большим количеством интервалов работы немного (менее 5%), как правило, это социально значимые организации. Например,&nbsp;УФМС в Москве&nbsp;-&nbsp;[http://go.2gis.ru/nzit](http://go.2gis.ru/nzit)&nbsp;. В случае, если у&nbsp;организации более трёх интервалов работы,&nbsp;необходимо оставить табличное представление.&nbsp;

&nbsp; &nbsp;![](./img/table.png)

##### Отображения комментария ко времени работы

Если ко времени работы организации указан комментарий, отображаем его только в раскрытой карточке:&nbsp;

![](./img/schedule-comment.png "Комментарий-ко-времени-работы")

В случае если время работы организации одинаково для всех дней недели или организация работает круглосуточно комментарий отображается после краткой записи

![](./img/24x7-comment.png "Круглосуточно,-коммент.")&nbsp;

![](./img/everyday-comment.png "Коммент-ко-времени-работы,-свёрнутое-время-работы.png")

### Подсказки ко времени работы

В свёрнутом виде у времени работы появляются подсказки. Задача - помочь пользователю определить работает организация сейчас или нет.

Используется цветовое кодирование иконки (зеленая - если организация работает, серая - если организация закрыта) и тестовая подсказка.

**Финальные версии текстов для подсказок**
<table>
    <tr>
        <th>График работы </th>
        <th>Подсказка</th>
    </tr>
    <tr>
        <td>Сегодня 09:00 – 20:00 </td>
        <td><b>Открыто до 20:00</b></td>
    </tr>
    <tr>
        <td>Сегодня 09:00 – 20:00 </td>
        <td><b>Откроется завтра</b></td>
    </tr>
    <tr>
        <td>Сегодня 09:00 – 20:00 </td>
        <td><b>Закроется через 15 минут</b></td>
    </tr>
    <tr>
        <td>Сегодня 09:00 – 20:00 </td>
        <td><b>Открыто. Меньше 5 минут до закрытия</b></td>
    </tr>
    <tr>
        <td>Сегодня 09:00 – 20:00 </td>
        <td><b>Закроется через 5 минут</b></td>
    </tr>
    <tr>
        <td>Сегодня 09:00 – 20:00, обед 13:00 – 14:00 </td>
        <td><b>Закроется через 15 минут</b></td>
    </tr>
    <tr>
        <td>Сегодня 09:00 – 20:00, обед 13:00 – 14:00</td>
        <td><b>Откроется через 15 минут</b></td>
    </tr>
    <tr>
        <td>Сегодня 09:00 – 20:00 </td>
        <td><b>Откроется через 15 минут</b></td>
    </tr>
    <tr>
        <td>Сегодня выходной</td>
        <td><b>Откроется в понедельник</b></td>
    </tr>
</table>


##### Подсказки при использовании фильтра "Работает сейчас"

Если пользователь отфильтровал результаты поиска по "Работает сейчас" подсказка должна отображаться и для скрытой карточки предприятия.&nbsp;

![](./img/open-now.png "Работает-сейчас")

### Дополнительные требования и&nbsp;ограничения

1.  Время работы оцениваем по часовому поясу проекта в котором находится организация. Т.е. если человек из Новосибирска в просматривает профиль московской организации - время до закрытия должно считаться по московскому времени.&nbsp;
2.  Не учитываем переходы на летнее\зимнее время.
3.  Не учитываем праздники.

### Примеры карточек


![](./img/worktimescreen.png "worktimescreen.png")


================================================
FILE: vendors/firmcard/src/Dictionary.js
================================================
/*global
    FirmCard:false
*/
// FirmCard.dictionary = {};

FirmCard.prototype.dict = {

    t: function (lang, msg, argument) { // (String, Number) -> String
        var result,
            msgIsset = false,
            dictionaryMsg,
            exp;

        if (typeof this[lang] === 'undefined') {
            if (lang === 'ar') {
                lang = 'en';
            } else {
                lang = 'ru';
            }
        }
        dictionaryMsg = this[lang][msg];
        msgIsset = typeof dictionaryMsg !== 'undefined';
        if (!msgIsset) {
            return msg;
        }
        result = msgIsset ? dictionaryMsg : msg;

        if (argument !== undefined) {
            argument = parseInt(argument, 10);
            argument = isNaN(argument) ? 0 : argument;
            exp = this[lang].pluralRules(argument);
            result = argument + ' ' + dictionaryMsg[exp];
        }
        return result;
    },

    ru: {
        pluralRules: function (n) { // (Number)
            if (n % 10 === 1 && n % 100 !== 11) { // 1, 21
                return 0;
            }
            if ((n % 10 >= 2 && n % 10 <= 4 && (n % 10) % 1 === 0) && (n % 100 < 12 || n % 100 > 14)) { // 2, 3
                return 1;
            }

            if ((n % 10 === 0) || (n % 10 >= 5 && n % 10 <= 9 && (n % 10) % 1 === 0) || (n % 100 >= 11 && (n % 100) <= 14 && (n % 100) % 1 === 0)) { // 13, 17
                return 2;
            }
        },

        btnBack: 'Назад',
        btnFindWay: 'Проехать сюда',
        btnEntrance: 'Найти вход',
        linkReviews: ['отзыв', 'отзыва', 'отзывов'],
        linkPhoto: ['фото', 'фото', 'фото'],
        linkBooklet: 'Буклет',
        tommorow: 'завтра',
        afterTommorow: 'послезавтра',
        afterWeek: 'через неделю',
        nextSun: 'в воскресенье',
        nextMon: 'в понедельник',
        nextTue: 'во вторник',
        nextWed: 'в среду',
        nextThu: 'в четверг',
        nextFri: 'в пятницу',
        nextSat: 'в субботу',
        willOpen: 'откроется',
        willClose: 'закроется',
        isOpen: 'Открыто',
        openTill: 'Открыто до ',
        closeIn: 'Закроется через ',
        openAt: 'Откроется в ',
        openIn: 'Откроется через ',
        open: 'Откроется ',
        nHours: ['час', 'часа', 'часов'],
        nMins: ['минуту', 'минуты', 'минут'],
        lunch: 'обед',
        Lunch: 'Обед. ',
        workingDays: 'Рабочие дни',
        weekdays: 'Будние дни',
        restDay: ['выходной', 'выходные','выходные'],
        reviewsOnFlamp: 'Отзывы на Флампе',
        writeReviewOnFlamp: 'Написать отзыв на Флампе',
        payment: 'оплата',
        everyday: 'Ежедневно c',
        worksAroundTheClock: 'Работает круглосуточно',
        aroundTheClock: 'Круглосуточно',
        knowMore: 'узнать больше',
        toClose: 'до закрытия',
        monday: 'понедельник',
        tuesday: 'вторник',
        wednesday: 'среда',
        thursday: 'четверг',
        friday: 'пятница',
        saturday: 'суббота',
        sunday: 'воскресенье',
        mon: 'пон',
        tue: 'втр',
        wed: 'срд',
        thu: 'чтв',
        fri: 'птн',
        sat: 'сбт',
        sun: 'вск',
        toLunch: 'до обеда',
        today: 'Сегодня',
        lessThenHour: 'менее часа',
        youCouldLate: 'вы можете не успеть',
        workingTime: 'рабочее время',
        showAllOrgInRubric: 'Показать все организации рубрики',
        todayIsRestDay: 'Сегодня выходной',
        internet: 'Оплата через Интернет',
        noncash: 'Безналичный расчет',
        goldcrown: 'Золотая Корона',
        dinersclub: 'Diners Club',
        mastercard: 'Mastercard',
        maestrocard: 'MaestroCard',
        visa: 'Visa',
        cash: 'Наличный расчет',
        americanexpress: 'American Express',
        hour : 'час',
        less: 'менее',
        _in : 'Через',
        isClosingOnDinner : ' закрывается на обед'
    },

    it: {
        pluralRules: function (n) { // (Number)
            if (n === 1) { // 1
                return 0;
            } else {
                return 1; //0, 2, 3, 4 ..
            }
        },

        btnBack: 'Indietro',
        btnFindWay: 'Come arrivare ',
        btnEntrance: 'Trova l\'ingresso',
        linkReviews: ['recensione', 'recensioni'],
        linkPhoto: ['fotografia', 'fotografie'],
        linkBooklet: 'Sull\'azienda',
        tommorow: 'domani',
        afterTommorow: 'dopodomani',
        afterWeek: 'tra una settimana',
        nextSun: 'la domenica',
        nextMon: 'il lunedi',
        nextTue: 'il martedì',
        nextWed: 'il mercoledì',
        nextThu: 'il giovedi',
        nextFri: 'il venerdì',
        nextSat: 'il sabato',
        willOpen: 'apre',
        willClose: 'ciuso',
        isOpen: 'Aperto',
        openTill: 'Aperto fino alle ',
        closeIn: 'Chiude tra ',
        openAt: 'Apre alle ',
        openIn: 'Apre tra ',
        open: 'Apre ',
        nHours: ['ora', 'ore'],
        nMins: ['minuto', 'minuti'],
        lunch: 'pausa pranzo',
        Lunch: 'Pausa pranzo. ',
        workingDays: 'Giorni feriali',
        weekdays: 'Giorni feriali',
        restDay: ['chiusura','chiusura'],
        reviewsOnFlamp: 'Recensioni su Flamp',
        writeReviewOnFlamp: 'Scrivi una recensione su Flamp',
        payment: 'pagamento',
        everyday: 'Ogni giorno dalole',
        worksAroundTheClock: 'Operativo 24 ore su 24',
        aroundTheClock: '24 ore su 24',
        knowMore: 'ulteriori informazioni',
        toClose: 'fino alla chiusura',
        monday: 'lunedi',
        tuesday: 'martedì',
        wednesday: 'mercoledì',
        thursday: 'giovedi',
        friday: 'venerdì',
        saturday: 'sabato',
        sunday: 'domenica',
        mon: 'lun',
        tue: 'mar',
        wed: 'mer',
        thu: 'gio',
        fri: 'ven',
        sat: 'sab',
        sun: 'dom',
        toLunch: 'fino alla pausa pranzo',
        today: 'Oggi',
        lessThenHour: 'meno di un\'ora',
        youCouldLate: 'affrettarsi, chiusura imminente',
        workingTime: 'orario di lavoro',
        showAllOrgInRubric: 'Visualizza tutte le aziende della categoria',
        todayIsRestDay: 'oggi chiuso',
        internet: 'Pagamento on-line',
        noncash: 'Pagamento non in contanti',
        goldcrown: 'Zolotaja Korona',
        dinersclub: 'Diners Club',
        mastercard: 'MasterCard',
        maestrocard: 'MaestroCard',
        visa: 'Visa',
        cash: 'Pagamento in contanti',
        americanexpress: 'American Express',
        hour : 'un\'ora',
        less: 'meno di',
        _in : 'Tra',
        isClosingOnDinner : 'chiude per pausa pranzo'
    },

    en: {
        pluralRules: function (n) { // (Number)
            if (n === 1) { // 1
                return 0;
            } else {
                return 1; //0, 2, 3, 4 ..
            }
        },

        btnBack: 'Back',
        btnFindWay: 'Get here',
        btnEntrance: 'Find entrance',
        linkReviews: ['review', 'reviews'],
        linkPhoto: ['photo', 'photos'],
        linkBooklet: 'About company',
        tommorow: 'tomorrow',
        afterTommorow: 'the day after tomorrow',
        afterWeek: 'in a week',
        nextSun: 'on Sunday',
        nextMon: 'on Monday',
        nextTue: 'on Tuesday',
        nextWed: 'on Wednesday',
        nextThu: 'on Thursday',
        nextFri: 'on Friday',
        nextSat: 'on Saturday',
        willOpen: 'opens ',
        willClose: 'closes',
        isOpen: 'Open',
        openTill: 'Open till ',
        closeIn: 'Closes in ',
        openAt: 'Opens at ',
        openIn: 'Opens in ',
        open: 'Opens ',
        nHours: ['hour', 'hours'],
        nMins: ['minute', 'minutes'],
        lunch: 'lunch break',
        Lunch: 'Lunch break. ',
        workingDays: 'Working days',
        weekdays: 'Weekdays',
        restDay: ['day off','days off'],
        reviewsOnFlamp: 'Reviews on Flamp',
        writeReviewOnFlamp: 'Write a review on Flamp',
        payment: 'payment',
        everyday: 'Daily from',
        worksAroundTheClock: 'Open 24 hours',
        aroundTheClock: '24h',
        knowMore: 'see also',
        toClose: 'until closing',
        monday: 'Monday',
        tuesday: 'Tuesday',
        wednesday: 'Wednesday',
        thursday: 'Thursday',
        friday: 'Friday',
        saturday: 'Saturday',
        sunday: 'Sunday',
        mon: 'Mon',
        tue: 'Tue',
        wed: 'Wed',
        thu: 'Thu',
        fri: 'Fri',
        sat: 'Sat',
        sun: 'Sun',
        toLunch: 'until lunch',
        today: 'Today',
        lessThenHour: 'less then one hour',
        youCouldLate: 'you might be late',
        workingTime: 'working hours',
        showAllOrgInRubric: 'Show all organizations in the category',
        todayIsRestDay: 'closed today',
        internet: 'Online',
        noncash: ' No-cash',
        goldcrown: 'Golden Crown',
        dinersclub: 'Diners Club',
        mastercard: 'Mastercard',
        maestrocard: 'MaestroCard',
        visa: 'Visa',
        cash: 'Cash',
        americanexpress: 'American Express',
        hour : 'hour',
        less: 'less',
        _in : 'In',
        isClosingOnDinner : 'will be closing for lunch'
    },

    cs: {
        pluralRules: function (n) { // (Number)
            return (n === 1) ? 0 : (n >= 2 && n <= 4) ? 1 : 2;
        },

        btnBack: 'Zpět',
        btnFindWay: 'Jet sem',
        btnEntrance: 'Hledat vstup',
        linkReviews: ['recenze', 'recenze', 'recenzí'],
        linkPhoto: ['fotografie', 'fotografie', 'fotografií'],
        linkBooklet: 'Leták',
        tommorow: 'zítra',
        afterTommorow: 'pozítří',
        afterWeek: 'za týden',
        nextSun: 'v neděli',
        nextMon: 'v pondělí',
        nextTue: 'v úterý',
        nextWed: 've středu',
        nextThu: 've čtvrtek',
        nextFri: 'v pátek',
        nextSat: 'v sobotu',
        willOpen: 'otevře se',
        willClose: 'zavře se',
        isOpen: 'Otevřeno',
        openTill: 'Otevřeno do ',
        closeIn: 'Zavře se za ',
        openAt: 'Otevře se v ',
        openIn: 'Otevře se za ',
        open: 'Otevře se ',
        nHours: [ 'hodinu' , 'hodiny' , 'hodin' ],
        nMins: [ 'minutu' , 'minuty' , 'minut' ],
        lunch: 'polední přestávka',
        Lunch: 'Polední přestávka. ',
        workingDays: 'Všední dny',
        weekdays: 'Všední dny',
        restDay: ['zavřeno', 'zavřeno'],
        reviewsOnFlamp: 'Recenze na Flampu',
        writeReviewOnFlamp: 'Napsat recenzi na Flampu',
        payment: 'platba',
        everyday: 'Denně od ',
        worksAroundTheClock: 'Pracuje nonstop',
        aroundTheClock: 'Nonstop',
        knowMore: 'dozvědět se více',
        toClose: 'do uzavření',
        monday: 'pondělí',
        tuesday: 'úterý',
        wednesday: 'středa',
        thursday: 'čtvrtek',
        friday: 'pátek',
        saturday: 'sobota',
        sunday: 'neděle',
        mon: 'po',
        tue: 'út',
        wed: 'st',
        thu: 'čt',
        fri: 'pá',
        sat: 'so',
        sun: 'ne',
        toLunch: 'do polední přestávky',
        today: 'Dnes',
        lessThenHour: 'méně než hodinu',
        youCouldLate: 'nemusíte to stihnout',
        workingTime: 'pracovní doba',
        showAllOrgInRubric: 'Zobrazit všechny organizace v rubrice',
        todayIsRestDay: 'Dnes je zavřeno',
        internet: 'Platba prostřednictvím Internetu',
        noncash: 'Bezhotovostní platba',
        goldcrown: 'Zolotaja Korona',
        dinersclub: 'Diners Club',
        mastercard: 'Mastercard',
        maestrocard: 'MaestroCard',
        visa: 'Visa',
        cash: 'Platba hotově',
        americanexpress: 'American Express',
        hour : 'hodinu',
        less: 'méně',
        _in : 'Za',
        isClosingOnDinner : 'začíná polední přestávka'
    },

    es: {
        pluralRules: function (n) { // (Number)
          return (n === 1) ? 0 : (n >= 2 && n <= 4) ? 1 : 2;
        },

        btnBack: 'Atrás',
        btnFindWay: 'Ir para allá',
        btnEntrance: 'Buscar acceso',
        linkReviews: ['comentario', 'comentarios', 'comentarios'],
        linkPhoto: ['foto', 'fotos', 'fotos'],
        linkBooklet: 'Folleto',
        tommorow: 'mañana',
        afterTommorow: 'pasado mañana',
        afterWeek: 'en una semana más',
        nextSun: 'el domingo',
        nextMon: 'el lunes',
        nextTue: 'el martes',
        nextWed: 'el miércoles',
        nextThu: 'el jueves',
        nextFri: 'el viernes',
        nextSat: 'el sábado',
        willOpen: 'se abrirá',
        willClose: 'se cerrará',
        isOpen: 'Abierto',
        openTill: 'Abierto hasta ',
        closeIn: 'Se cerrará dentro de ',
        openAt: 'Se abrirá el ',
        openIn: 'Se abrirá dentro de ',
        open: 'Se abrirá ',
        nHours: ['hora', 'horas', 'horas'],
        nMins: ['minuto', 'minutos', 'minutos'],
        lunch: 'hora de colación',
        Lunch: 'Hora de colación. ',
        workingDays: 'Días laborables',
        weekdays: 'Días laborables',
        restDay: ['cerrado','cerrado'],
        reviewsOnFlamp: 'Comentarios en Flamp',
        writeReviewOnFlamp: 'Escribir un comentario en Flamp',
        payment: 'pago',
        everyday: 'Cada día desde',
        worksAroundTheClock: 'Abierto las 24 horas',
        aroundTheClock: '24 horas',
        knowMore: 'para saber más',
        toClose: 'hasta el cierre',
        monday: 'lunes',
        tuesday: 'martes',
        wednesday: 'miércoles',
        thursday: 'jueves',
        friday: 'viernes',
        saturday: 'sábado',
        sunday: 'domingo',
        mon: 'lun',
        tue: 'mar',
        wed: 'mié',
        thu: 'jue',
        fri: 'vie',
        sat: 'sáb',
        sun: 'dom',
        toLunch: 'antes de la hora de colación',
        today: 'Hoy',
        lessThenHour: 'menos de una hora',
        youCouldLate: 'puede ser que no alcanzas a llegar',
        workingTime: 'horario de trabajo',
        showAllOrgInRubric: 'Mostrar todas las empresas de la categoría',
        todayIsRestDay: 'Hoy cerrado',
        internet: 'Pago por Internet',
        noncash: 'Pago sin efectivo',
        goldcrown: 'Zolotaya Korona',
        dinersclub: 'Diners Club',
        mastercard: 'Mastercard',
        maestrocard: 'MaestroCard',
        visa: 'Visa',
        cash: 'Pago en efectivo',
        americanexpress: 'American Express',
        hour : 'hora',
        less: 'menos de',
        _in : 'Dentro de',
        isClosingOnDinner : 'se cierra por hora de colación'
    }
};


================================================
FILE: vendors/firmcard/src/FirmCard.DataHelper.js
================================================
FirmCard.DataHelper = {
	payMethods : [
		'americanexpress',
		'cash',
		'dinersclub',
		'goldcrown',
		'internet',
		'mastercard',
		'noncash',
		'visa'
	],

	_msgs : {},

	getFlampUrl : function (id) {
	    return DG.config.flampUrl.concat(id, '?', DG.config.flampGoogleAnalytics);
	},

	msg : function (msg) {
		if (this._msgs.hasOwnProperty(msg)) {
			return this._msgs[msg];
		}
		console && console.log("Cant't find translation for '" + msg + "'.");
		return msg.toString().replace('_', ' ');
	},

	getProjectTime: function (timezoneOffset, time) {
        var now, utc;

        if (time) {
            now = new Date(time);
        } else {
            now = new Date();
        }

        if (timezoneOffset) {
            utc = now.getTime() + (now.getTimezoneOffset() * 60000);
            return new Date(utc + (60000 * timezoneOffset));
        } else {
            return now;
        }
    }
};


================================================
FILE: vendors/firmcard/src/FirmCard.js
================================================
var FirmCard = function (firm, options) {
    this._setOptions(options);
    this._firmContentObject = {};
    this._schedule = new FirmCard.Schedule({
        localLang: this.options.lang,
        dict: this.dict
    });

    this.render(firm);
};

FirmCard.prototype = {

    render: function (firmId) {
        if (!firmId) { return; }

        if (firmId !== this._firmId) {
            this._firmContentObject = {};
            this._renderCardById(firmId);
        } else {
            this._toggleEventHandlers();
        }

        return this._firmContentObject;
    },

    getSchedule: function () {
        return this._schedule;
    },

    getContainer: function () {
        return this._container;
    },

    _renderCardById: function (firmId) {
        var self = this;

        this.options.ajax(firmId).then(function (res) {
            if (!res) { return false; }
            var data = res.result.items;
            if (data !== 'undefined') {
                self._firmData = data[0];

                // Support for old WebAPI format.
                // TODO: remove this call after WebAPI release
                self._convertWebsite();

                self._firmId = firmId;
                self._renderFirmCard();
                self._toggleEventHandlers();
            }
        }, function (error) {
            self._renderError();
        });
    },

    _createFirmContainer: function () {
        var firm = document.createElement('div');
        firm.setAttribute('id', 'dg-map-firm-full-' + this._firmId);
        firm.setAttribute('class', 'dg-map-firm-full');

        return firm;
    },

    _getPaymentTypes: function (data) {
        var result = [],
            groupName = 'general_payment_type';

        if (!data.attribute_groups) {
            return result;
        }

        data.attribute_groups.forEach(function (group) {
            if (group.name) {
                return;
            }

            group.attributes.forEach(function (attr) {
                if (attr.tag.substring(0, groupName.length) === groupName) {
                    result.push(attr.name);
                }
            });
        });

        return result;
    },

    _groupRubrics: function (data) {
        var result = {
            primary: [],
            additional: []
        };

        if (!data.rubrics || !data.rubrics.length) {
            return result;
        }

        data.rubrics.forEach(function (rubric) {
            result[rubric.kind].push(rubric);
        });

        return result;
    },

    // Support for old WebAPI format.
    // TODO: remove this function after WebAPI release
    _convertWebsite: function () {
        if (!this._firmData.contact_groups) {
            return;
        }

        this._firmData.contact_groups.forEach(function (group) {
            if (!group.contacts) {
                return;
            }

            group.contacts.forEach(function (contact) {
                if (contact.type != 'website') {
                    return;
                }

                if (!contact.url) {
                    contact.url = contact.value;
                }
            });
        });
    },

    _renderFirmCard: function () {
        var firmCardBody, schedule, forecast, links, btns, paymentTypes, rubrics,
            data = this._firmData,
            container = this._container = this._createFirmContainer();

        schedule = this._schedule.transform(data.schedule, {
            zoneOffset: this.options.timezoneOffset,
            apiLang: this.options.lang,
            localLang: this.options.lang
        });

        forecast = this._schedule.forecast(schedule);

        paymentTypes = this._getPaymentTypes(data);
        rubrics = this._groupRubrics(data);

        firmCardBody = this._buildFirmCardBody(
            this._getConfigFirmCardBody(data, schedule, forecast, paymentTypes, rubrics)
        );

        links = this._fillHeaderLinks();
        btns = this._fillFooterButtons();

        //fill object for view render
        this._firmContentObject.header = this.options.render('firmCardHeader', {'firmName': data.name, 'links': links});
        container.innerHTML = firmCardBody;
        this._firmContentObject.tmpl = container;
        if (btns.length) {
            this._footerContainer = document.createElement('div');

            this._footerContainer.innerHTML = this.options.render('popupFooterBtns', {'btns': btns});
            this._firmContentObject.footer = this._footerContainer;
        }

        if (this.options.onFirmReady) {
            this.options.onFirmReady(this._firmContentObject);
        }
    },

    _renderError: function() {
        this._firmContentObject.header = this.options.render('popupHeader', {
            title: this.options.t('apiErrorTitle')
        });

        this._firmContentObject.tmpl = this.options.t('apiErrorBody');

        if (this.options.onFirmReady) {
            this.options.onFirmReady(this._firmContentObject);
        }
    },

    _getConfigFirmCardBody: function (data, schedule, forecast, attributes, rubrics) {
        return [
            {
                tmpl: 'firmCardAddr',
                data: {
                    address: data.address_name,
                    comment: data.address_comment
                }
            },
            {
                tmpl: 'firmCardContacts',
                data: {
                    groups: data.contact_groups
                }
            },
            {
                tmpl: 'firmCardSchedule',
                data: {
                    schedule: schedule,
                    forecast: forecast
                }
            },
            {
                tmpl: 'frimCardPayments',
                data: {
                    payments: attributes
                }
            },
            {
                tmpl: 'firmCardRubric',
                data: {
                    rubrics: rubrics
                }
            }
        ];
    },

    _buildFirmCardBody: function (parts) {
        var self = this;
        return parts.reduce(function (body, item) {
            var html = self.options.render(item.tmpl, item.data);
            return body + html;
        }, '');
    },

    _fillFooterButtons: function () {
        var btns = [];

        if (this.options.backBtn) {
            btns.push({ name: 'firm-card-back',
                        label: this.dict.t(this.options.lang, 'btnBack'),
                        icon: true
            });
        }

        if (this.options.showRouteSearch) {
            btns.push({ name: 'goto',
                        label: this.dict.t(this.options.lang, 'btnFindWay'),
                        icon: true,
                        href: this.options.gotoUrl
            });
        }

        if (
            this._firmData.links &&
                this._firmData.links.entrances &&
                this.options.showEntrance
        ) {
            btns.push({ name: 'show-entrance',
                        label: this.dict.t(this.options.lang, 'btnEntrance'),
                        icon: true
            });
        }

        return btns;
    },

    _fillHeaderLinks: function () {
        var links = [],
            reviewData = this._firmData.reviews,
            booklet,
            link;

        if (this._firmData.external_content) {
            this._firmData.external_content.forEach(function (el) {
                if (el && el.type == 'booklet') {
                    booklet = el;
                }
            });
        }

        if (reviewData && reviewData.is_reviewable) {
            links.push({
                name: 'flamp_stars',
                width: reviewData.rating * 20
            });
            links.push({
                name: 'flamp_reviews',
                label: this.dict.t(this.options.lang, 'linkReviews', reviewData.review_count ? reviewData.review_count : 0),
                href: FirmCard.DataHelper.getFlampUrl(this._firmId)
            });
        }

        // Retrieve photo data from external content block
        var photos;
        var externalContent = this._firmData.external_content;

        for (var i = 0; i < externalContent.length; i++) {
            if (
                externalContent[i].type == 'photo_album' &&
                externalContent[i].subtype == 'common'
            ) {
                photos = externalContent[i];
                break;
            }
        }

        if (!this.options.isMobile && photos && photos.count && this.options.showPhotos) {
            link = L.Util.template(DG.config.photosLink, {
                'id': this._firmId,
                'domain': this.options.domain
            });

            links.push({name: 'photos',
                href: link,
                label: this.dict.t(this.options.lang, 'linkPhoto', photos.count)
            });
        }

        if (!this.options.isMobile && booklet && booklet.url && this.options.showBooklet) {
            links.push({
                name: 'booklet',
                href:  booklet.url,
                label: this.dict.t(this.options.lang, 'linkBooklet')
            });
        }


        return links;
    },

    _events: {
        'dg-popup__button_name_firm-card-back': function() {
            this.options.backBtn();
            this._toggleEventHandlers(true);
        },
        'dg-popup__button_name_show-entrance': function() {
            var ent = new this.options.showEntrance({'vectors': this._firmData.links.entrances[0].geometry.vectors});
            ent.addTo(this.options.map);
            ent.fitBounds();
            this._toggleEventHandlers(true);
        },
        'dg-schedule__today': function() {
            this._onToggleSchedule();
        }
    },

    _toggleEventHandlers: function (flag) {
        this.options.popup[flag ? 'off' : 'on']('click', this._onClick, this);
        this.options.map[flag ? 'off' : 'on']('popupclose', this._onClose, this);
    },

    _onClick: function (e) {
        var target = e.originalEvent.target;

        for (var eventClass in this._events) {
            if (this._events.hasOwnProperty(eventClass) && target.className.indexOf(eventClass) > -1) {
                DG.DomEvent.preventDefault(e.originalEvent);
                this._events[eventClass].call(this, target);
                return;
            }
        }
    },

    _onClose: function (e) {
        this._toggleEventHandlers(true);
    },

    _onToggleSchedule: function () {
        var schedule = this._container.querySelector('.dg-schedule__table'),
            forecast = this._container.querySelector('.dg-schedule__now'),
            target = this._container.querySelector('.dg-schedule__today'),
            showClass = ' dg-schedule__today_shown_true';

        if (!schedule) { return; }

        if (schedule.style.display === 'block') {
            schedule.style.display = 'none';
            forecast.style.display = 'block';
            target.className = target.className.replace(showClass, '');
        } else {
            forecast.style.display = 'none';
            schedule.style.display = 'block';
            target.className += showClass;
        }

        if (this.options.onToggle) {
            this.options.onToggle();
        }
    },

    _setOptions: function (options) {
        var option,
            options = options || {};

        this.options = options;
        options.lang = options.lang || 'ru';

        for (option in options) {
            if (options.hasOwnProperty(option)) {
                this.options[option] = options[option];
            }
        }
    },

    _hasTouch: function () {
        return (('ontouchstart' in window) ||
                (navigator.maxTouchPoints > 0) ||
                (navigator.msMaxTouchPoints > 0));
    }
};


================================================
FILE: vendors/firmcard/src/FirmList.js
================================================
/* global
    FirmCard: false
*/
(function () {
    FirmCard.List = function (firms, options) {
        this._firms = {}; // {'firmID': firmDomObj}
        this._setOptions(options);

        this._container = options && options.container || document.createElement('ul');
        this._container.setAttribute('class', 'dg-building-callout__list');

        this._eventHandlersInited = false;
        this._firmCard = this._createFirm();
        this.renderList(firms);
    };

    FirmCard.List.prototype = {

        renderList: function (firms) {
            if (firms) {
                this._toggleEventHandlers();
                this.addFirms(firms);
            }
            if (this.options.onListReady) {
                this.options.onListReady(this._container);
            }

            return this._container;
        },

        _processFirms: function (firms, action) {
            if (!firms) { return; }
            var method = '_' + action + 'Firm';
            if (this._isArray(firms)) {
                for (var i = 0, l = firms.length; i < l; i++) {
                    this[method](firms[i]);
                }
            } else {
                this[method](firms);
            }

        },

        addFirms: function(firms) {
            this._processFirms(firms, 'add');
        },

        removeFirms: function(firms) {
            this._processFirms(firms, 'remove');
        },

        setLang: function (newLang) {
            this.options.firmCard.lang = newLang;
        },

        getLang: function () {
            return this.options.firmCard.lang;
        },

        getContainer: function () {
            return this._container;
        },

        clearList : function () {
            this._firms = {};
            this._toggleEventHandlers(true);
            this._clearContainer();
        },

        _removeFirm: function (id) {
            if (!this._firms[id]) { return false; }
            this._container.removeChild(this._firms[id]);
            delete this._firms[id];
        },

        _addFirm: function (firmData) {
            var tmpl = this.options.firmlistItemTmpl,
                domFirm, firm, content;

            firm = {
                name: firmData.name,
                id: firmData.id.split('_').slice(0, 1)
            };

            if (!(firm.id in this._firms)) {

                domFirm = this._createListItem();

                content = tmpl ? this.options.firmCard.render(tmpl, {'firm': firm}) : firm.name;

                domFirm.insertAdjacentHTML('beforeend', content);

                this._firms[firm.id] = domFirm;
                this._container.appendChild(domFirm);
            }
        },

        _createListItem: function () {
            var item = document.createElement('li');
            item.setAttribute('class', 'dg-building-callout__list-item');

            return item;
        },

        _isArray: function (obj) {
            return {}.toString.call(obj) === '[object Array]';
        },

        _createFirm: function (firmData) {
            return new FirmCard(firmData, this.options.firmCard);
        },

        _isEmptyObj: function (obj) {
            for (var prop in obj) {
                if (obj.hasOwnProperty(prop)) {
                    return false;
                }
            }

            return true;
        },

        _events: {
            'dg-popup__link': function(target) {
                var s = this._firmCard.render(target.id);

                this.options.firmCard[this._isEmptyObj(s) ? 'pasteLoader' : 'onFirmReady'](s);

                this.options.firmCard.onFirmClick && this.options.firmCard.onFirmClick();

                this._toggleEventHandlers(true);
            },
            'dg-building-callout__list-item': function(target) {
                target = target.children[0];

                this._events['dg-popup__link'].call(this, target);
            },
            'dg-popup__button_name_back': function() {
                this.options.firmCard.onShowLess();

                this._toggleEventHandlers(true);
            }
        },

        _toggleEventHandlers : function (flag) {
            this.options.firmCard.popup[flag ? 'off' : 'on']('click', this._onClick, this);
        },

        _onClick: function (e) {
            var target = e.originalEvent.target;

            for (var eventClass in this._events) {
                if (this._events.hasOwnProperty(eventClass) && target.className.indexOf(eventClass) > -1) {
                    DG.DomEvent.preventDefault(e.originalEvent);
                    this._events[eventClass].call(this, target);
                    return;
                }
            }
        },

        _clearContainer: function () {
            var container = this._container;

            while (container.hasChildNodes()) {
                container.removeChild(container.firstChild);
            }
        },

        _setOptions: function (options) {
            options || (options = {});
            this.options = options;
            this.options.firmCard || (this.options.firmCard = {});

            if (!options.firmCard.lang) {
                this.options.firmCard.lang = 'ru';
            }

            for (var option in options) {
                if (options.hasOwnProperty(option)) {
                    this.options[option] = options[option];
                }
            }
        }
    };
})();


================================================
FILE: vendors/firmcard/src/Schedule.js
================================================
/*global
    FirmCard:false
*/
FirmCard.Schedule = function (options) {
    options = options || {};

    this.localLang = options.localLang || 'ru';
    this.dict = options.dict;
    return this;
};

FirmCard.Schedule.prototype = {

    setLang: function (lang) {
        this.localLang = lang || 'ru';
        return this;
    },

    transform: function (model, params) {
        if (!model) {
            return;
        }
        params = params || {};

        function bind(fn, obj) { // (Function, Object) -> Function
            var args = arguments.length > 2 ? Array.prototype.slice.call(arguments, 2) : null;
            return function () {
                return fn.apply(obj, args || arguments);
            };
        }

        var todayKey, // Mon, Tue ...
            today, // Объект модели - текущий день недели
            from, // Самое раннее время открытия за день
            to, // Самое позднее время закрытия за день
            zoneOffset = params.zoneOffset || 0,
            schedule = {}, // Объект-расписание, формируемый под шаблон
            now = params.now || FirmCard.DataHelper.getProjectTime(zoneOffset).getTime(), // Current timestamp in milliseconds
            weekKeys = [], // Ключи дней недели, определяют порядок дней и первый день недели. 0 - первый день недели в регионе (не обязательно Mon)
            weekKeysLocal = [],
            weekFullKeysLocal = [],
            weekKeysShort =  [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ],
            weekKeysFull = ['monday','tuesday','wednesday','thursday','friday','saturday','sunday'],
            localLang = params.localLang || this.localLang,
            localWorkingDays = params.localWorkingDays || [0, 1, 1, 1, 1, 1, 0],
            firstdayOffset = params.firstdayOffset || 1,
            minHoursToDisplayClosure = params.minHoursToDisplayClosure || 4,
            t = bind(this.dict.t, this.dict);


        function capitaliseFirstLetter(string) {
            return string.charAt(0).toUpperCase() + string.slice(1);
        }

        function getHours(str) {
            return str.substr(0, 2);
        }

        function getMinutes(str) {
            return str.substr(3, 2);
        }

        // Конвертация временной точки формата апи в формат отображения (25:00 -> 01:00)
        function formatTime(str) {
            var hours = +getHours(str) % 24 + '';

            if (hours.length === 1) {
                hours = '0' + hours;
            }

            return hours + ':' + getMinutes(str);
        }

        // Конвертация int числа в номер дня недели (диапазон 0-6)
        // отрицательные чила: -1 вернёт 6, -2 -> 5 и т.д
        // положительные: 7 -> 0, 8 -> 1
        function dayNum(n) {
            return (n + 70) % 7;
        }


        /* jshint ignore:start */
        // Возвращает последний элемент массива
        // Взято из Underscore.js http://underscorejs.org/#last
        function getArrayLast(arr, n) {
            if ( arr == null ) return void 0;
            if (   n == null ) return arr[ arr.length - 1 ];
            return slice.call( arr, Math.max(arr.length - n , 0) );
        }


        // Выполняет глубокое сравнение объектов
        // Взято из Underscore.js http://underscorejs.org/#isEqual
        // Упрощено для тех трёх сравнений, которые выполняются в Shedule.js
        function isEqual(obj1, obj2) {
            if ( obj1 === obj2 ) return true;
            if ( ! ( obj1 instanceof Object ) || ! ( obj2 instanceof Object ) ) return false;
            if ( obj1.constructor !== obj2.constructor ) return false;
            for ( var prop in obj1 ) {
                if ( ! obj1.hasOwnProperty( prop ) ) continue;
                if ( ! obj2.hasOwnProperty( prop ) ) return false;
                if ( obj1[ prop ] === obj2[ prop ] ) continue;
                if ( typeof( obj1[ prop ] ) !== "object" ) return false;
                if ( ! isEqual( obj1[ prop ],  obj2[ prop ] ) ) return false;
            }
            for ( prop in obj2 ) {
            if ( obj2.hasOwnProperty( prop ) && ! obj1.hasOwnProperty( prop ) ) return false;
            }

            return true;
        }

        // Generate an integer Array containing an arithmetic progression. A port of
        // the native Python `range()` function. See
        // [the Python documentation](http://docs.python.org/library/functions.html#range).
        function range(start, stop, step) {
        if (arguments.length <= 1) {
            stop = start || 0;
            start = 0;
        }
        step = arguments[2] || 1;

        var length = Math.max(Math.ceil((stop - start) / step), 0);
        var idx = 0;
        var range = new Array(length);
        while(idx < length) {
            range[idx++] = start;
            start += step;
        }

        return range;
        }


        //Заполняет свойства объекта значениями по умолчанию
        //Взято из Underscore.js http://underscorejs.org/#defaults
        function fillDefaults(obj) {
         var args = Array.prototype.slice.call(arguments, 1);
         args.forEach(function(source) {
            if (source) {
                for (var prop in source) {
                    if (obj[prop] === void 0) obj[prop] = source[prop];
                }
            }
        });
        return obj;
        }

        //Сортирует значения согласно с итератором
        //Взято с Underscore.js http://underscorejs.org/#sortBy
        function sortBy(obj, iterator){
            return pluck(obj.map( function(value, index, list) {
                return {
                        value: value,
                        index: index,
                        criteria: iterator.call(this, value, index, list)
                        };
                }).sort(function(left, right) {
                        var a = left.criteria;
                        var b = right.criteria;
                        if (a !== b) {
                        if (a > b || a === void 0) return 1;
                        if (a < b || b === void 0) return -1;
                        }
                return left.index - right.index;
                }), 'value');
        }

        /* jshint ignore:end */

        function pluck(arr, key){
            var i, rv = [];
            for (i = 0; i < arr.length; ++i) {
            rv[i] = arr[i][key];
            }
            return rv;
        }


        // Преобразовать расписание на день в упорядоченный массив временных отсечек (string)
        // Сейчас полагается, что API уже выдаёт сортированный массив
        function getSortedTimePoints(day) {
            var points = [],
                from, to,
                deltaHours, deltaMinutes;

            if (!day || !day.working_hours) {
                return [];
            }

            for (var i = 0 ; i < day.working_hours.length ; i++) {
                from = day.working_hours[i].from;
                to = day.working_hours[i].to;

                deltaHours = getHours(to) - getHours(from);
                deltaMinutes = getMinutes(to) - getMinutes(from);
                if (deltaHours < 0 || (deltaHours === 0 && deltaMinutes <= 0)) { // Если "до" меньше или равно "от" - значит указывает на завтра
                    to = (+getHours(to) + 24) + ':' + getMinutes(to); // (01:00 -> 25:00)
                }

                points[i * 2] = {
                    time: from,
                    type: 'open'
                };
                points[i * 2 + 1] = {
                    time: to,
                    type: day.working_hours.length - 1 === i ? 'close' : 'lunch'
                };
            }

            return points;
        }

        // Возвращает массив timestamp всех точек, всех дней недели, от сегодняшнего и в будущее
        // Например, сегодня среда, отсечки будут взяты для дат со среды (сегодня) по следующий вторник включительно
        function getTimeStamps(model) {
            var timestamps = [],
                out = [],
                timePoints,
                num = weekKeys.indexOf(todayKey); // Номер сегодняшнего дня недели (для данного региона)


            // Цикл по дням недели начиная с сегодняшнего
            var j; // Номер текущего дня в массиве weekKeys
            for (var i = 0 ; i < 7 ; i++) {
                j = dayNum(num + i);
                timePoints = getSortedTimePoints(model[weekKeys[j]]);
                // Цикл по точкам времени с конвертацией в timestamp
                timePoints.forEach(
                    /* jshint -W083 */
                    function (point) {
                    // now - обязательно! иначе будет браться текущий timestamp что чревато несовпадениями при медленном быстродействии
                    // Вычислить таймстемп для данного дня недели, часа и минуты, в будущем, но ближайший к now
                    var tsp = new Date(now);
                    tsp.setDate(tsp.getDate()+i);
                    tsp.setHours(getHours(point.time));
                    tsp.setMinutes(getMinutes(point.time));
                    var ts = tsp.getTime();



                    timestamps.push({
                        ts: ts,
                        type: point.type
                    });

                    if (timestamps[timestamps.length - 1] && timestamps[timestamps.length - 2]) {
                        // Парно удаляем совпадающие точки (они не имеют смысла - это сегодня 24:00 и завтра 00:00)
                        if (timestamps[timestamps.length - 1].ts === timestamps[timestamps.length - 2].ts) {
                            timestamps.pop();
                            timestamps.pop();
                        }
                    }

                    if (timestamps[timestamps.length - 1] && timestamps[timestamps.length - 2]) {
                        // Парно переносим точки в будущее, если они обе в прошлом (первая точка ([0]) должна быть всегда открытием!)
                        if (timestamps[timestamps.length - 1].ts <= now && timestamps[timestamps.length - 2].ts <= now) {
                            timestamps[timestamps.length - 1].ts += (7 * 24 * 60 * 60 * 1000);
                            timestamps[timestamps.length - 2].ts += (7 * 24 * 60 * 60 * 1000);
                        }
                    }
                }
                /* jshint +W083 */
                );
            }

            // Сортируем на возрастание, ведь возможно были переносы в будущее
            timestamps = sortBy(timestamps, function (timestamp) { return timestamp.ts; });

            // Удаляем попарно совпадающие точки времени
            i = 0;
            while (i < timestamps.length) {
                if (timestamps[i + 1] && timestamps[i].ts === timestamps[i + 1].ts) {
                    i++;
                } else {
                    out.push(timestamps[i].ts);
                }
                i++;
            }

            // Проверка на ежедневно-круглосуточность
            if (out.length === 2 && (out[1] - out[0]) === (7 * 24 * 60 * 60 * 1000)) {
                return [];
            }

            return timestamps;
        }

        function whenOpenInverse(h, d, num) {
            if (d === 1 && h > minHoursToDisplayClosure ) {
                return t(localLang, 'tommorow');
            } else if (d > 1) {
                /* jshint -W015 */
                switch (num) {
                    case 0: return t(localLang, 'nextSun');
                    case 1: return t(localLang, 'nextMon');
                    case 2: return t(localLang, 'nextTue');
                    case 3: return t(localLang, 'nextWed');
                    case 4: return t(localLang, 'nextThu');
                    case 5: return t(localLang, 'nextFri');
                    case 6: return t(localLang, 'nextSat');
                }
                /* jshint +W015 */
            }

            return;
        }


        //Возвращает интервал в целых днях, с поправкой на смену дня в полночь, между
        // @param timestampEnd и @param dateStart
        function dayInterval(timestampEnd, dateStart) {

            var oneDay = 1000 * 60 * 60 * 24,
                dateEnd = new Date(timestampEnd.ts);

            var diff;

            diff = Math.round((dateEnd - dateStart) / oneDay);

            if( timestampEnd.type==='open' && dateEnd.getHours() < 1 )
                { diff ++; }

            return diff;
        }


        // Поместить данные в объект для шаблона о сегодняшнем дне
        function setTodayString(today) {

            var timePoints,
                periods = [],
                timestamps;

            schedule.now = {};

            // Timestamps всех отсечек
            timestamps = getTimeStamps(model);

            if (!timestamps.length) {
                schedule.always = true; // Работает ежедневно круглосуточно
                schedule.now.open = true;
            }


            for (var i = 0 ; i < timestamps.length ; i++) {
                // Попали между точками i-1 и i // Мы находимся заведомо в будущем относительно 1
                if (now >= (timestamps[i - 1] && timestamps[i - 1].ts || 0) && now < timestamps[i].ts) {
                    var h = Math.floor((timestamps[i].ts - now) / (1000 * 60 * 60)), // Количество часов до следующего timestamp
                        m = Math.floor((timestamps[i].ts - now) / (1000 * 60) - h * 60), // Количество минут (без часов) до следующего timestamp
                        dayNow = new Date(now),

                        // открыто если следующая итерация не открытие
                        nowIsOpen = timestamps[i].type !== 'open';

                        //var d = dayOfYear(dayTs) - dayOfYear(dayNow);
                        //var d = dayInterval(dayTs, dayNow, nowIsOpen);
                        var d = dayInterval(timestamps[i], dayNow);



                    // округляем минуты до кратных 5
                    m = Math.floor(m / 10) * 10 ? Math.floor(m / 10) * 10 : 5;

                    schedule.now.open = nowIsOpen;
                    schedule.now.lunch = !!(timestamps[i - 1] && timestamps[i - 1].type === 'lunch' || getArrayLast(timestamps).type === 'lunch');

                    schedule.will = {
                        willType: timestamps[i].type,
                        d: d,
                        h: h,
                        m: m
                    };

                    // Когда закроется или откроется
                    var willWhen = new Date(timestamps[i].ts);
                    schedule.will.when = whenOpenInverse(h, d, willWhen.getDay());


                    var willTill = new Date(timestamps[i].ts),
                        strHours = willTill.getHours(),
                        strMinutes = willTill.getMinutes();

                    if (strHours < 10) { strHours = '0' + strHours; }
                    if (strMinutes < 10) { strMinutes = '0' + strMinutes; }

                    schedule.will.till = strHours+':'+strMinutes;
                }
            }

            if (!today) {
                return; // На сегодня расписания нет - сейчас закрыто
            }

            timePoints = pluck(getSortedTimePoints(today), 'time');

            // Цикл по периодам работы за день
            for (i = 2 ; i < timePoints.length ; i = i + 2) {
                periods.push({ from: timePoints[i - 1], to: timePoints[i] });
            }

            from = formatTime(timePoints[0]);
            to = formatTime(timePoints[timePoints.length - 1]);

            if (from === to) { // Круглосуточно
                schedule.today = {
                    alltime: true,
                    alltimeStr: t(localLang, 'worksAroundTheClock'),
                    from: '00:00',
                    to: '24:00'
                };
            } else { // От from до to
                schedule.today = {
                    from: from,
                    to: to
                };
            }

            if (periods.length > 0) { // Перерывы на обед
                schedule.lunch = periods;
                schedule.lunchStr = t(localLang, 'lunch');
            }
        }

        // Формирование объекта-таблицы-расписания для шаблона
        function makeTable() {
            var column = [],
                hasLunch = false;

            for (var j = 0 ; j < 7 ; j++) {
                var dayKey = weekKeys[j],
                    lunchMaxLength = 0;

                column[j] = {};

                if (model[dayKey]) {
                    var day = model[dayKey],
                        timePoints = pluck(getSortedTimePoints(day), 'time'),
                        lunch = []; // Отрезки времени (отсортированные моменты) на обеды

                    // Цикл по периодам работы за день
                    for (var i = 2 ; i < timePoints.length ; i = i + 2) {
                        hasLunch = true;
                        lunch.push({ from: timePoints[i - 1], to: timePoints[i] });
                    }
                    lunchMaxLength = Math.max(timePoints.length / 2, lunchMaxLength);

                    column[j] = {
                        from: formatTime(timePoints[0]),
                        to: formatTime(timePoints[timePoints.length - 1]),
                        lunch: lunch
                    };
                }

                if (dayKey === todayKey) { // Сегодняшний день надо подсветить
                    column[j].active = true;
                }

                column[j].key = weekKeysLocal[j];
            }

            // Дополнение пустыми объектами массивов lunch
            column.forEach( function (col) {
                if (col.lunch) {
                    fillDefaults(col.lunch, range(1, lunchMaxLength));
                }
            });

            return {
                table: column,
                hasLunch: hasLunch
            };
        }

        // Сгенерировать строку для всех дней model, совпадающих с day
        function makeSimpleString(day, model) {
            var points,
                out = {
                    dayList: [],
                    lunch: []
                },
                lunchesTime = [];

            if (day && day.working_hours && day.working_hours.length) {
                points = pluck(getSortedTimePoints(day), 'time');
                points.forEach( function (point, key) {
                    if (key === 0) {
                        out.from = formatTime(point);
                    } else if (key === points.length - 1) {
                        out.to = formatTime(point);
                    } else {
                        lunchesTime.push(formatTime(point));
                    }
                });
                for (var i = 0; i < lunchesTime.length; i += 2) {
                    out.lunch.push({
                        from: lunchesTime[i],
                        to: lunchesTime[i + 1],
                        lunchStr: capitaliseFirstLetter(t(localLang, 'lunch'))
                    });
                }

                if (out.from == '00:00' && out.to == '00:00') {
                    out.to = '24:00';
                }

                if (day.round_the_clock) {
                    out.alltime = true;
                    out.alltimeStr = t(localLang, 'worksAroundTheClock');
                }
            } else { // Выходной
                out.holiday = true;
            }

            // Формируем список дней на локальном языке
            var groupWorkingDays = [0, 0, 0, 0, 0, 0, 0]; // Флаги работы фирмы в дни текущей группы
            var flow = 0;

            weekKeys.forEach( function (dayKey, numKey) { // 'Mon', 0
                if (isEqual(model[dayKey], day) || (!model[dayKey] && day === null)) {
                    out.dayList.push(weekFullKeysLocal[numKey]);
                    groupWorkingDays[dayNum(numKey + firstdayOffset)] = 1;
                    flow++;
                } else {
                    if (flow > 2) { // Более 2 дней подряд
                        var lastDay = out.dayList.pop();

                        for (var i = 1 ; i < flow - 1 ; i++) {
                            out.dayList.pop();
                        }

                        out.dayList[out.dayList.length - 1] += ' — ' + lastDay;
                    }

                    flow = 0;
                }
            });

            // Список дней в данной группе идентичен списку будних дней, значит можно заменить словом "Будни"
            out.budni = isEqual(localWorkingDays, groupWorkingDays);
            // Список рабочих дней - все дни недели, значит нужно выводить фразу "Ежедневно"
            out.everyday = ( Math.min.apply(Math, groupWorkingDays) === 1 );

            if ( out.holiday ) { out.holidayStr = t(localLang, 'restDay', out.dayList.length).slice(2); }

            // Делаем из массива строку и поднимаем первый символ
            out.dayList = out.dayList.join(', ');
            out.dayList = out.dayList.charAt(0).toUpperCase() + out.dayList.slice(1);


            return out;
        }

        // Возвращает массив simple строк на основе массива дней days
        function makeAdvancedString(days, model) {
            var out = [];

            for (var i = days.length - 1 ; i >= 0 ; i--) {
                out.push(makeSimpleString(days[i], model));
            }

            return out;
        }

        // Заполняем названия дней недели, 1 - понедельник. В заполненных массивах понедельник это 0

        for (var i = 0 ; i < 7 ; i++) {
            weekKeys[i] = weekKeysShort[i];
            weekKeysLocal[i] = this.dict.t(localLang, weekKeysShort[i].toLowerCase());
            weekFullKeysLocal[i] = this.dict.t(localLang, weekKeysFull[i]);
        }

        // Вычисляем сегодняшний день недели (ссылку на объект дня в модели)
        todayKey = weekKeysShort[dayNum(new Date(now).getDay() - firstdayOffset)];
        today = model[todayKey]; // Объект расписания - текущий день недели
        setTodayString(today); // Сделать объект для шаблона - строка, которая описывает время работы сегодня

        // Находим количество разных расписаний и сохраняем их в массив
        var apiDifferentDays = [], // Массив различающихся дней из модели
            apiScheduleDaysCount = 0, // Количество описанных дней в расписании модели
            apiDifferentDaysCount = 0, // Количество разных дней в расписании модели
            differentWorkingHoursCount = []; // Количество рабочих часов в разных днях

        Object.keys(model).forEach( function(day) {
            if (model[day] && model[day].working_hours) { // Проверяем что это день, а не комментарий или что-то ещё
                apiScheduleDaysCount++;
                if (!isEqual(model[day], getArrayLast(apiDifferentDays))) {
                    apiDifferentDays.push(model[day]);
                }
            }
        });

        apiDifferentDaysCount = apiDifferentDays.length;
        // Если не все дни описаны в модели, значит есть ещё один тип дней - выходной (отсутствущий в модели)
        if (apiScheduleDaysCount < 7) {
            apiDifferentDaysCount++;
        }

        // Если разных более 2, то упростить не получится - делаем таблицу
        if (apiDifferentDaysCount > 2) {
            schedule.week = makeTable(model);
        } else { // Иначе, составляем комментарий из двух строк

            // Случай, когда все одинаковые
            if (apiDifferentDaysCount === 1) {
                schedule.week = {
                    evently: [makeSimpleString(model[weekKeys[0]], model)]
                };
            } else { // Остаётся случай, когда есть два типа дней
                // Определяем день с наибольшим количеством рабочих часов из числа разных дней
                for (i = 0 ; i < apiDifferentDaysCount ; i++) {
                    differentWorkingHoursCount[i] = 0;

                    if (apiDifferentDays[i]) {
                        var points = pluck(getSortedTimePoints(apiDifferentDays[i]), 'time');

                        for (var j = 0 ; j < points.length ; j = j + 2) {
                            var hours = (getHours(points[j + 1]) + getMinutes(points[j + 1]) / 60) - (getHours(points[j]) + getMinutes(points[j]) / 60);
                            differentWorkingHoursCount[i] += hours;
                        }
                    } else { // Выходной
                        apiDifferentDays[i] = null;
                    }
                }

                var apiSortedDifferentDays = sortBy(apiDifferentDays, function (day, key) {
                    return differentWorkingHoursCount[key];
                });

                schedule.week = {
                    evently: makeAdvancedString(apiSortedDifferentDays, model)
                };
            }
        }

        schedule.comment = model.comment;
        if (schedule.week && schedule.week.evently && schedule.week.evently.length === 1) {
            schedule.everyday = schedule.week.evently[0].everyday;
        }
        return schedule;
    },

    forecast: function (schedule, params) {
        var interval = '',
        open,
        today = {},
        nowText,
        maxHours = params && params.maxHours || 1;

        if (!schedule) {
            return {};
        }

        if (schedule.always) { // Круглосуточно ежедневно - более ничего выводить не нужно
            return {
                today: {
                    text: this.dict.t(this.localLang, 'aroundTheClock')
                },
                open: true
            };
        }

        // Формируем строку - через сколько произойдёт следующая инверсия открытости
        if (schedule.will && schedule.will.h < maxHours) {
            if (schedule.will.h) {
                interval += this.dict.t(this.localLang, 'nHours', schedule.will.h) + ' ';
            }

            if (schedule.will.m) {
                interval += this.dict.t(this.localLang, 'nMins', schedule.will.m);
            }
        }

        // Данные на сегодня
        if (schedule.today) {
            today.text = this.dict.t(this.localLang, 'today');
            if (schedule.everyday) {
                today.text = this.dict.t(this.localLang, 'everyday');
            }
            today.from = schedule.today.from;
            today.to = schedule.today.to;
            today.lunch = schedule.lunch;
            if (today.lunch) {
                today.lunchStr = this.dict.t(this.localLang, 'lunch');
            }
        } else {
            today.text = this.dict.t(this.localLang, 'todayIsRestDay');
        }

        // Текущий статус и прогноз
        if (schedule.always) { // Если круглосуточно, ничего кроме "Круглосуточно" выводить не нужно
            today.text = this.dict.t(this.localLang, 'aroundTheClock');
            open = true;
        } else if (schedule.now) {
            open = schedule.now.open;
            if (open) { // открыто
                if (schedule.will && schedule.will.willType === 'lunch') {
                    // далее - закрытие на обед
                    if (schedule.will && schedule.will.h < maxHours) {
                        // менее maxHours до закрытия  на обед
                        nowText = this.dict.t(this.localLang, '_in') + ' ' + this.dict.t(this.localLang, 'nMins', interval) + this.dict.t(this.localLang, 'isClosingOnDinner');
                    } else {
                        // больше maxHours до закрытия  на обед
                        nowText = this.dict.t(this.localLang, 'isOpen');
                    }

                } else {
                    // далее просто закрытие
                    if (schedule.will.h < maxHours) {
                        // менее maxHours до закрытия просто
                        nowText = this.dict.t(this.localLang, 'closeIn') + this.dict.t(this.localLang, 'nMins', interval);
                    } else {
                        // больше maxHours до закрытия просто
                        nowText = this.dict.t(this.localLang, 'isOpen');
                    }
                }
            } else { // закрыто
                if (schedule.will && schedule.will.when) {
                    // откроется не сегодня
                    nowText = this.dict.t(this.localLang, 'open') + schedule.will.when;
                } else {
                    // откроется сегодня
                    if (schedule.now && schedule.now.lunch) {
                        // сейчас обед
                        if (schedule.will.h < maxHours) {
                            // менее maxHours до открытия с обеда
                            nowText = this.dict.t(this.localLang, 'Lunch') + this.dict.t(this.localLang, 'openIn') + this.dict.t(this.localLang, 'nMins', interval);
                        } else {
                            // больше maxHours до открытия с обеда
                            nowText = this.dict.t(this.localLang, 'Lunch') + this.dict.t(this.localLang, 'openAt') + schedule.will.till;
                        }
                    } else {
                        // просто закрыто
                        if (schedule.will && schedule.will.h < maxHours) {
                            // менее maxHours до открытия просто
                            nowText = this.dict.t(this.localLang, 'openIn') + this.dict.t(this.localLang, 'nMins', interval);
                        } else {
                            // больше maxHours до открытия просто
                            nowText = this.dict.t(this.localLang, 'openAt') + schedule.will.till;
                        }
                    }
                }
            }
        }

        return {
            today: today,
            now: nowText,
            open: open,
            week: schedule.week,
            comment: schedule.comment,
            everyday: schedule.everyday
        };
    }
};


================================================
FILE: vendors/firmcard/src/vendors/momentjs/lang/moment.cs.js
================================================
// moment.js language configuration
// language : czech (cs)
// author : petrbela : https://github.com/petrbela
!function(){function e(e){function t(e){return e>1&&5>e&&1!==~~(e/10)}function a(e,a,n,_){var s=e+" ";switch(n){case"s":return a||_?"p\xe1r vte\u0159in":"p\xe1r vte\u0159inami";case"m":return a?"minuta":_?"minutu":"minutou";case"mm":return a||_?s+(t(e)?"minuty":"minut"):s+"minutami";break;case"h":return a?"hodina":_?"hodinu":"hodinou";case"hh":return a||_?s+(t(e)?"hodiny":"hodin"):s+"hodinami";break;case"d":return a||_?"den":"dnem";case"dd":return a||_?s+(t(e)?"dny":"dn\xed"):s+"dny";break;case"M":return a||_?"m\u011bs\xedc":"m\u011bs\xedcem";case"MM":return a||_?s+(t(e)?"m\u011bs\xedce":"m\u011bs\xedc\u016f"):s+"m\u011bs\xedci";break;case"y":return a||_?"rok":"rokem";case"yy":return a||_?s+(t(e)?"roky":"let"):s+"lety"}}var n="leden_\xfanor_b\u0159ezen_duben_kv\u011bten_\u010derven_\u010dervenec_srpen_z\xe1\u0159\xed_\u0159\xedjen_listopad_prosinec".split("_"),_="led_\xfano_b\u0159e_dub_kv\u011b_\u010dvn_\u010dvc_srp_z\xe1\u0159_\u0159\xedj_lis_pro".split("_");e.lang("cs",{months:n,monthsShort:_,monthsParse:function(e,t){var a,n=[];for(a=0;12>a;a++)n[a]=new RegExp("^"+e[a]+"$|^"+t[a]+"$","i");return n}(n,_),weekdays:"ned\u011ble_pond\u011bl\xed_\xfater\xfd_st\u0159eda_\u010dtvrtek_p\xe1tek_sobota".split("_"),weekdaysShort:"ne_po_\xfat_st_\u010dt_p\xe1_so".split("_"),weekdaysMin:"ne_po_\xfat_st_\u010dt_p\xe1_so".split("_"),longDateFormat:{LT:"H:mm",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY LT",LLLL:"dddd D. MMMM YYYY LT"},calendar:{sameDay:"[dnes v] LT",nextDay:"[z\xedtra v] LT",nextWeek:function(){switch(this.day()){case 0:return"[v ned\u011bli v] LT";case 1:case 2:return"[v] dddd [v] LT";case 3:return"[ve st\u0159edu v] LT";case 4:return"[ve \u010dtvrtek v] LT";case 5:return"[v p\xe1tek v] LT";case 6:return"[v sobotu v] LT"}},lastDay:"[v\u010dera v] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulou ned\u011bli v] LT";case 1:case 2:return"[minul\xe9] dddd [v] LT";case 3:return"[minulou st\u0159edu v] LT";case 4:case 5:return"[minul\xfd] dddd [v] LT";case 6:return"[minulou sobotu v] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"p\u0159ed %s",s:a,m:a,mm:a,h:a,hh:a,d:a,dd:a,M:a,MM:a,y:a,yy:a},ordinal:"%d.",week:{dow:1,doy:4}})}"function"==typeof define&&define.amd&&define(["moment"],e),"undefined"!=typeof window&&window.moment&&e(window.moment)}();

================================================
FILE: vendors/firmcard/src/vendors/momentjs/lang/moment.it.js
================================================
// moment.js language configuration
// language : italian (it)
// author : Lorenzo : https://github.com/aliem
// author: Mattia Larentis: https://github.com/nostalgiaz
!function(){function e(e){e.lang("it",{months:"Gennaio_Febbraio_Marzo_Aprile_Maggio_Giugno_Luglio_Agosto_Settembre_Ottobre_Novembre_Dicembre".split("_"),monthsShort:"Gen_Feb_Mar_Apr_Mag_Giu_Lug_Ago_Set_Ott_Nov_Dic".split("_"),weekdays:"Domenica_Luned\xec_Marted\xec_Mercoled\xec_Gioved\xec_Venerd\xec_Sabato".split("_"),weekdaysShort:"Dom_Lun_Mar_Mer_Gio_Ven_Sab".split("_"),weekdaysMin:"D_L_Ma_Me_G_V_S".split("_"),longDateFormat:{LT:"HH:mm",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY LT",LLLL:"dddd, D MMMM YYYY LT"},calendar:{sameDay:"[Oggi alle] LT",nextDay:"[Domani alle] LT",nextWeek:"dddd [alle] LT",lastDay:"[Ieri alle] LT",lastWeek:"[lo scorso] dddd [alle] LT",sameElse:"L"},relativeTime:{future:function(e){return(/^[0-9].+$/.test(e)?"tra":"in")+" "+e},past:"%s fa",s:"secondi",m:"un minuto",mm:"%d minuti",h:"un'ora",hh:"%d ore",d:"un giorno",dd:"%d giorni",M:"un mese",MM:"%d mesi",y:"un anno",yy:"%d anni"},ordinal:"%d\xba",week:{dow:1,doy:4}})}"function"==typeof define&&define.amd&&define(["moment"],e),"undefined"!=typeof window&&window.moment&&e(window.moment)}();

================================================
FILE: vendors/firmcard/src/vendors/momentjs/lang/moment.ru.js
================================================
// moment.js language configuration
// language : russian (ru)
// author : Viktorminator : https://github.com/Viktorminator
// Author : Menelion Elensúle : https://github.com/Oire
!function(){function e(e){function t(e,t){var n=e.split("_");return 1===t%10&&11!==t%100?n[0]:t%10>=2&&4>=t%10&&(10>t%100||t%100>=20)?n[1]:n[2]}function n(e,n,a){var _={mm:"\u043c\u0438\u043d\u0443\u0442\u0430_\u043c\u0438\u043d\u0443\u0442\u044b_\u043c\u0438\u043d\u0443\u0442",hh:"\u0447\u0430\u0441_\u0447\u0430\u0441\u0430_\u0447\u0430\u0441\u043e\u0432",dd:"\u0434\u0435\u043d\u044c_\u0434\u043d\u044f_\u0434\u043d\u0435\u0439",MM:"\u043c\u0435\u0441\u044f\u0446_\u043c\u0435\u0441\u044f\u0446\u0430_\u043c\u0435\u0441\u044f\u0446\u0435\u0432",yy:"\u0433\u043e\u0434_\u0433\u043e\u0434\u0430_\u043b\u0435\u0442"};return"m"===a?n?"\u043c\u0438\u043d\u0443\u0442\u0430":"\u043c\u0438\u043d\u0443\u0442\u0443":e+" "+t(_[a],+e)}function a(e,t){var n={nominative:"\u044f\u043d\u0432\u0430\u0440\u044c_\u0444\u0435\u0432\u0440\u0430\u043b\u044c_\u043c\u0430\u0440\u0442_\u0430\u043f\u0440\u0435\u043b\u044c_\u043c\u0430\u0439_\u0438\u044e\u043d\u044c_\u0438\u044e\u043b\u044c_\u0430\u0432\u0433\u0443\u0441\u0442_\u0441\u0435\u043d\u0442\u044f\u0431\u0440\u044c_\u043e\u043a\u0442\u044f\u0431\u0440\u044c_\u043d\u043e\u044f\u0431\u0440\u044c_\u0434\u0435\u043a\u0430\u0431\u0440\u044c".split("_"),accusative:"\u044f\u043d\u0432\u0430\u0440\u044f_\u0444\u0435\u0432\u0440\u0430\u043b\u044f_\u043c\u0430\u0440\u0442\u0430_\u0430\u043f\u0440\u0435\u043b\u044f_\u043c\u0430\u044f_\u0438\u044e\u043d\u044f_\u0438\u044e\u043b\u044f_\u0430\u0432\u0433\u0443\u0441\u0442\u0430_\u0441\u0435\u043d\u0442\u044f\u0431\u0440\u044f_\u043e\u043a\u0442\u044f\u0431\u0440\u044f_\u043d\u043e\u044f\u0431\u0440\u044f_\u0434\u0435\u043a\u0430\u0431\u0440\u044f".split("_")},a=/D[oD]? *MMMM?/.test(t)?"accusative":"nominative";return n[a][e.month()]}function _(e,t){var n={nominative:"\u0432\u043e\u0441\u043a\u0440\u0435\u0441\u0435\u043d\u044c\u0435_\u043f\u043e\u043d\u0435\u0434\u0435\u043b\u044c\u043d\u0438\u043a_\u0432\u0442\u043e\u0440\u043d\u0438\u043a_\u0441\u0440\u0435\u0434\u0430_\u0447\u0435\u0442\u0432\u0435\u0440\u0433_\u043f\u044f\u0442\u043d\u0438\u0446\u0430_\u0441\u0443\u0431\u0431\u043e\u0442\u0430".split("_"),accusative:"\u0432\u043e\u0441\u043a\u0440\u0435\u0441\u0435\u043d\u044c\u0435_\u043f\u043e\u043d\u0435\u0434\u0435\u043b\u044c\u043d\u0438\u043a_\u0432\u0442\u043e\u0440\u043d\u0438\u043a_\u0441\u0440\u0435\u0434\u0443_\u0447\u0435\u0442\u0432\u0435\u0440\u0433_\u043f\u044f\u0442\u043d\u0438\u0446\u0443_\u0441\u0443\u0431\u0431\u043e\u0442\u0443".split("_")},a=/\[ ?[\u0412\u0432] ?(?:\u043f\u0440\u043e\u0448\u043b\u0443\u044e|\u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0443\u044e)? ?\] ?dddd/.test(t)?"accusative":"nominative";return n[a][e.day()]}e.lang("ru",{months:a,monthsShort:"\u044f\u043d\u0432_\u0444\u0435\u0432_\u043c\u0430\u0440_\u0430\u043f\u0440_\u043c\u0430\u0439_\u0438\u044e\u043d_\u0438\u044e\u043b_\u0430\u0432\u0433_\u0441\u0435\u043d_\u043e\u043a\u0442_\u043d\u043e\u044f_\u0434\u0435\u043a".split("_"),weekdays:_,weekdaysShort:"\u0432\u0441\u043a_\u043f\u043d\u0434_\u0432\u0442\u0440_\u0441\u0440\u0434_\u0447\u0442\u0432_\u043f\u0442\u043d_\u0441\u0431\u0442".split("_"),weekdaysMin:"\u0432\u0441_\u043f\u043d_\u0432\u0442_\u0441\u0440_\u0447\u0442_\u043f\u0442_\u0441\u0431".split("_"),longDateFormat:{LT:"HH:mm",L:"DD.MM.YYYY",LL:"D MMMM YYYY \u0433.",LLL:"D MMMM YYYY \u0433., LT",LLLL:"dddd, D MMMM YYYY \u0433., LT"},calendar:{sameDay:"[\u0421\u0435\u0433\u043e\u0434\u043d\u044f \u0432] LT",nextDay:"[\u0417\u0430\u0432\u0442\u0440\u0430 \u0432] LT",lastDay:"[\u0412\u0447\u0435\u0440\u0430 \u0432] LT",nextWeek:function(){return 2===this.day()?"[\u0412\u043e] dddd [\u0432] LT":"[\u0412] dddd [\u0432] LT"},lastWeek:function(){switch(this.day()){case 0:return"[\u0412 \u043f\u0440\u043e\u0448\u043b\u043e\u0435] dddd [\u0432] LT";case 1:case 2:case 4:return"[\u0412 \u043f\u0440\u043e\u0448\u043b\u044b\u0439] dddd [\u0432] LT";case 3:case 5:case 6:return"[\u0412 \u043f\u0440\u043e\u0448\u043b\u0443\u044e] dddd [\u0432] LT"}},sameElse:"L"},relativeTime:{future:"\u0447\u0435\u0440\u0435\u0437 %s",past:"%s \u043d\u0430\u0437\u0430\u0434",s:"\u043d\u0435\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u0441\u0435\u043a\u0443\u043d\u0434",m:n,mm:n,h:"\u0447\u0430\u0441",hh:n,d:"\u0434\u0435\u043d\u044c",dd:n,M:"\u043c\u0435\u0441\u044f\u0446",MM:n,y:"\u0433\u043e\u0434",yy:n},ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":return e+"-\u0439";case"D":return e+"-\u0433\u043e";case"w":case"W":return e+"-\u044f";default:return e}},week:{dow:1,doy:7}})}"function"==typeof define&&define.amd&&define(["moment"],e),"undefined"!=typeof window&&window.moment&&e(window.moment)}();

================================================
FILE: vendors/firmcard/src/vendors/underscore1.5.1.js
================================================
//     Underscore.js 1.5.1
//     http://underscorejs.org
//     (c) 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
//     Underscore may be freely distributed under the MIT license.

(function() {

  // Baseline setup
  // --------------

  // Establish the root object, `window` in the browser, or `global` on the server.
  var root = this;

  // Save the previous value of the `_` variable.
  var previousUnderscore = root._;

  // Establish the object that gets returned to break out of a loop iteration.
  var breaker = {};

  // Save bytes in the minified (but not gzipped) version:
  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;

  // Create quick reference variables for speed access to core prototypes.
  var
    push             = ArrayProto.push,
    slice            = ArrayProto.slice,
    concat           = ArrayProto.concat,
    toString         = ObjProto.toString,
    hasOwnProperty   = ObjProto.hasOwnProperty;

  // All **ECMAScript 5** native function implementations that we hope to use
  // are declared here.
  var
    nativeForEach      = ArrayProto.forEach,
    nativeMap          = ArrayProto.map,
    nativeReduce       = ArrayProto.reduce,
    nativeReduceRight  = ArrayProto.reduceRight,
    nativeFilter       = ArrayProto.filter,
    nativeEvery        = ArrayProto.every,
    nativeSome         = ArrayProto.some,
    nativeIndexOf      = ArrayProto.indexOf,
    nativeLastIndexOf  = ArrayProto.lastIndexOf,
    nativeIsArray      = Array.isArray,
    nativeKeys         = Object.keys,
    nativeBind         = FuncProto.bind;

  // Create a safe reference to the Underscore object for use below.
  var _ = function(obj) {
    if (obj instanceof _) return obj;
    if (!(this instanceof _)) return new _(obj);
    this._wrapped = obj;
  };

  // Export the Underscore object for **Node.js**, with
  // backwards-compatibility for the old `require()` API. If we're in
  // the browser, add `_` as a global object via a string identifier,
  // for Closure Compiler "advanced" mode.
  if (typeof exports !== 'undefined') {
    if (typeof module !== 'undefined' && module.exports) {
      exports = module.exports = _;
    }
    exports._ = _;
  } else {
    root._ = _;
  }

  // Current version.
  _.VERSION = '1.5.1';

  // Collection Functions
  // --------------------

  // The cornerstone, an `each` implementation, aka `forEach`.
  // Handles objects with the built-in `forEach`, arrays, and raw objects.
  // Delegates to **ECMAScript 5**'s native `forEach` if available.
  var each = _.each = _.forEach = function(obj, iterator, context) {
    if (obj == null) return;
    if (nativeForEach && obj.forEach === nativeForEach) {
      obj.forEach(iterator, context);
    } else if (obj.length === +obj.length) {
      for (var i = 0, l = obj.length; i < l; i++) {
        if (iterator.call(context, obj[i], i, obj) === breaker) return;
      }
    } else {
      for (var key in obj) {
        if (_.has(obj, key)) {
          if (iterator.call(context, obj[key], key, obj) === breaker) return;
        }
      }
    }
  };

  // Return the results of applying the iterator to each element.
  // Delegates to **ECMAScript 5**'s native `map` if available.
  _.map = _.collect = function(obj, iterator, context) {
    var results = [];
    if (obj == null) return results;
    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
    each(obj, function(value, index, list) {
      results.push(iterator.call(context, value, index, list));
    });
    return results;
  };

  var reduceError = 'Reduce of empty array with no initial value';

  // **Reduce** builds up a single result from a list of values, aka `inject`,
  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
    var initial = arguments.length > 2;
    if (obj == null) obj = [];
    if (nativeReduce && obj.reduce === nativeReduce) {
      if (context) iterator = _.bind(iterator, context);
      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
    }
    each(obj, function(value, index, list) {
      if (!initial) {
        memo = value;
        initial = true;
      } else {
        memo = iterator.call(context, memo, value, index, list);
      }
    });
    if (!initial) throw new TypeError(reduceError);
    return memo;
  };

  // The right-associative version of reduce, also known as `foldr`.
  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
    var initial = arguments.length > 2;
    if (obj == null) obj = [];
    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
      if (context) iterator = _.bind(iterator, context);
      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
    }
    var length = obj.length;
    if (length !== +length) {
      var keys = _.keys(obj);
      length = keys.length;
    }
    each(obj, function(value, index, list) {
      index = keys ? keys[--length] : --length;
      if (!initial) {
        memo = obj[index];
        initial = true;
      } else {
        memo = iterator.call(context, memo, obj[index], index, list);
      }
    });
    if (!initial) throw new TypeError(reduceError);
    return memo;
  };

  // Return the first value which passes a truth test. Aliased as `detect`.
  _.find = _.detect = function(obj, iterator, context) {
    var result;
    any(obj, function(value, index, list) {
      if (iterator.call(context, value, index, list)) {
        result = value;
        return true;
      }
    });
    return result;
  };

  // Return all the elements that pass a truth test.
  // Delegates to **ECMAScript 5**'s native `filter` if available.
  // Aliased as `select`.
  _.filter = _.select = function(obj, iterator, context) {
    var results = [];
    if (obj == null) return results;
    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
    each(obj, function(value, index, list) {
      if (iterator.call(context, value, index, list)) results.push(value);
    });
    return results;
  };

  // Return all the elements for which a truth test fails.
  _.reject = function(obj, iterator, context) {
    return _.filter(obj, function(value, index, list) {
      return !iterator.call(context, value, index, list);
    }, context);
  };

  // Determine whether all of the elements match a truth test.
  // Delegates to **ECMAScript 5**'s native `every` if available.
  // Aliased as `all`.
  _.every = _.all = function(obj, iterator, context) {
    iterator || (iterator = _.identity);
    var result = true;
    if (obj == null) return result;
    if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
    each(obj, function(value, index, list) {
      if (!(result = result && iterator.call(context, value, index, list))) return breaker;
    });
    return !!result;
  };

  // Determine if at least one element in the object matches a truth test.
  // Delegates to **ECMAScript 5**'s native `some` if available.
  // Aliased as `any`.
  var any = _.some = _.any = function(obj, iterator, context) {
    iterator || (iterator = _.identity);
    var result = false;
    if (obj == null) return result;
    if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
    each(obj, function(value, index, list) {
      if (result || (result = iterator.call(context, value, index, list))) return breaker;
    });
    return !!result;
  };

  // Determine if the array or object contains a given value (using `===`).
  // Aliased as `include`.
  _.contains = _.include = function(obj, target) {
    if (obj == null) return false;
    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
    return any(obj, function(value) {
      return value === target;
    });
  };

  // Invoke a method (with arguments) on every item in a collection.
  _.invoke = function(obj, method) {
    var args = slice.call(arguments, 2);
    var isFunc = _.isFunction(method);
    return _.map(obj, function(value) {
      return (isFunc ? method : value[method]).apply(value, args);
    });
  };

  // Convenience version of a common use case of `map`: fetching a property.
  _.pluck = function(obj, key) {
    return _.map(obj, function(value){ return value[key]; });
  };

  // Convenience version of a common use case of `filter`: selecting only objects
  // containing specific `key:value` pairs.
  _.where = function(obj, attrs, first) {
    if (_.isEmpty(attrs)) return first ? void 0 : [];
    return _[first ? 'find' : 'filter'](obj, function(value) {
      for (var key in attrs) {
        if (attrs[key] !== value[key]) return false;
      }
      return true;
    });
  };

  // Convenience version of a common use case of `find`: getting the first object
  // containing specific `key:value` pairs.
  _.findWhere = function(obj, attrs) {
    return _.where(obj, attrs, true);
  };

  // Return the maximum element or (element-based computation).
  // Can't optimize arrays of integers longer than 65,535 elements.
  // See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)
  _.max = function(obj, iterator, context) {
    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
      return Math.max.apply(Math, obj);
    }
    if (!iterator && _.isEmpty(obj)) return -Infinity;
    var result = {computed : -Infinity, value: -Infinity};
    each(obj, function(value, index, list) {
      var computed = iterator ? iterator.call(context, value, index, list) : value;
      computed > result.computed && (result = {value : value, computed : computed});
    });
    return result.value;
  };

  // Return the minimum element (or element-based computation).
  _.min = function(obj, iterator, context) {
    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
      return Math.min.apply(Math, obj);
    }
    if (!iterator && _.isEmpty(obj)) return Infinity;
    var result = {computed : Infinity, value: Infinity};
    each(obj, function(value, index, list) {
      var computed = iterator ? iterator.call(context, value, index, list) : value;
      computed < result.computed && (result = {value : value, computed : computed});
    });
    return result.value;
  };

  // Shuffle an array.
  _.shuffle = function(obj) {
    var rand;
    var index = 0;
    var shuffled = [];
    each(obj, function(value) {
      rand = _.random(index++);
      shuffled[index - 1] = shuffled[rand];
      shuffled[rand] = value;
    });
    return shuffled;
  };

  // An internal function to generate lookup iterators.
  var lookupIterator = function(value) {
    return _.isFunction(value) ? value : function(obj){ return obj[value]; };
  };

  // Sort the object's values by a criterion produced by an iterator.
  _.sortBy = function(obj, value, context) {
    var iterator = lookupIterator(value);
    return _.pluck(_.map(obj, function(value, index, list) {
      return {
        value : value,
        index : index,
        criteria : iterator.call(context, value, index, list)
      };
    }).sort(function(left, right) {
      var a = left.criteria;
      var b = right.criteria;
      if (a !== b) {
        if (a > b || a === void 0) return 1;
        if (a < b || b === void 0) return -1;
      }
      return left.index < right.index ? -1 : 1;
    }), 'value');
  };

  // An internal function used for aggregate "group by" operations.
  var group = function(obj, value, context, behavior) {
    var result = {};
    var iterator = lookupIterator(value == null ? _.identity : value);
    each(obj, function(value, index) {
      var key = iterator.call(context, value, index, obj);
      behavior(result, key, value);
    });
    return result;
  };

  // Groups the object's values by a criterion. Pass either a string attribute
  // to group by, or a function that returns the criterion.
  _.groupBy = function(obj, value, context) {
    return group(obj, value, context, function(result, key, value) {
      (_.has(result, key) ? result[key] : (result[key] = [])).push(value);
    });
  };

  // Counts instances of an object that group by a certain criterion. Pass
  // either a string attribute to count by, or a function that returns the
  // criterion.
  _.countBy = function(obj, value, context) {
    return group(obj, value, context, function(result, key) {
      if (!_.has(result, key)) result[key] = 0;
      result[key]++;
    });
  };

  // Use a comparator function to figure out the smallest index at which
  // an object should be inserted so as to maintain order. Uses binary search.
  _.sortedIndex = function(array, obj, iterator, context) {
    iterator = iterator == null ? _.identity : lookupIterator(iterator);
    var value = iterator.call(context, obj);
    var low = 0, high = array.length;
    while (low < high) {
      var mid = (low + high) >>> 1;
      iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
    }
    return low;
  };

  // Safely create a real, live array from anything iterable.
  _.toArray = function(obj) {
    if (!obj) return [];
    if (_.isArray(obj)) return slice.call(obj);
    if (obj.length === +obj.length) return _.map(obj, _.identity);
    return _.values(obj);
  };

  // Return the number of elements in an object.
  _.size = function(obj) {
    if (obj == null) return 0;
    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
  };

  // Array Functions
  // ---------------

  // Get the first element of an array. Passing **n** will return the first N
  // values in the array. Aliased as `head` and `take`. The **guard** check
  // allows it to work with `_.map`.
  _.first = _.head = _.take = function(array, n, guard) {
    if (array == null) return void 0;
    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
  };

  // Returns everything but the last entry of the array. Especially useful on
  // the arguments object. Passing **n** will return all the values in
  // the array, excluding the last N. The **guard** check allows it to work with
  // `_.map`.
  _.initial = function(array, n, guard) {
    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
  };

  // Get the last element of an array. Passing **n** will return the last N
  // values in the array. The **guard** check allows it to work with `_.map`.
  _.last = function(array, n, guard) {
    if (array == null) return void 0;
    if ((n != null) && !guard) {
      return slice.call(array, Math.max(array.length - n, 0));
    } else {
      return array[array.length - 1];
    }
  };

  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
  // Especially useful on the arguments object. Passing an **n** will return
  // the rest N values in the array. The **guard**
  // check allows it to work with `_.map`.
  _.rest = _.tail = _.drop = function(array, n, guard) {
    return slice.call(array, (n == null) || guard ? 1 : n);
  };

  // Trim out all falsy values from an array.
  _.compact = function(array) {
    return _.filter(array, _.identity);
  };

  // Internal implementation of a recursive `flatten` function.
  var flatten = function(input, shallow, output) {
    if (shallow && _.every(input, _.isArray)) {
      return concat.apply(output, input);
    }
    each(input, function(value) {
      if (_.isArray(value) || _.isArguments(value)) {
        shallow ? push.apply(output, value) : flatten(value, shallow, output);
      } else {
        output.push(value);
      }
    });
    return output;
  };

  // Return a completely flattened version of an array.
  _.flatten = function(array, shallow) {
    return flatten(array, shallow, []);
  };

  // Return a version of the array that does not contain the specified value(s).
  _.without = function(array) {
    return _.difference(array, slice.call(arguments, 1));
  };

  // Produce a duplicate-free version of the array. If the array has already
  // been sorted, you have the option of using a faster algorithm.
  // Aliased as `unique`.
  _.uniq = _.unique = function(array, isSorted, iterator, context) {
    if (_.isFunction(isSorted)) {
      context = iterator;
      iterator = isSorted;
      isSorted = false;
    }
    var initial = iterator ? _.map(array, iterator, context) : array;
    var results = [];
    var seen = [];
    each(initial, function(value, index) {
      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
        seen.push(value);
        results.push(array[index]);
      }
    });
    return results;
  };

  // Produce an array that contains the union: each distinct element from all of
  // the passed-in arrays.
  _.union = function() {
    return _.uniq(_.flatten(arguments, true));
  };

  // Produce an array that contains every item shared between all the
  // passed-in arrays.
  _.intersection = function(array) {
    var rest = slice.call(arguments, 1);
    return _.filter(_.uniq(array), function(item) {
      return _.every(rest, function(other) {
        return _.indexOf(other, item) >= 0;
      });
    });
  };

  // Take the difference between one array and a number of other arrays.
  // Only the elements present in just the first array will remain.
  _.difference = function(array) {
    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
    return _.filter(array, function(value){ return !_.contains(rest, value); });
  };

  // Zip together multiple lists into a single array -- elements that share
  // an index go together.
  _.zip = function() {
    var length = _.max(_.pluck(arguments, "length").concat(0));
    var results = new Array(length);
    for (var i = 0; i < length; i++) {
      results[i] = _.pluck(arguments, '' + i);
    }
    return results;
  };

  // Converts lists into objects. Pass either a single array of `[key, value]`
  // pairs, or two parallel arrays of the same length -- one of keys, and one of
  // the corresponding values.
  _.object = function(list, values) {
    if (list == null) return {};
    var result = {};
    for (var i = 0, l = list.length; i < l; i++) {
      if (values) {
        result[list[i]] = values[i];
      } else {
        result[list[i][0]] = list[i][1];
      }
    }
    return result;
  };

  // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
  // we need this function. Return the position of the first occurrence of an
  // item in an array, or -1 if the item is not included in the array.
  // Delegates to **ECMAScript 5**'s native `indexOf` if available.
  // If the array is large and already in sort order, pass `true`
  // for **isSorted** to use binary search.
  _.indexOf = function(array, item, isSorted) {
    if (array == null) return -1;
    var i = 0, l = array.length;
    if (isSorted) {
      if (typeof isSorted == 'number') {
        i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
      } else {
        i = _.sortedIndex(array, item);
        return array[i] === item ? i : -1;
      }
    }
    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
    for (; i < l; i++) if (array[i] === item) return i;
    return -1;
  };

  // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
  _.lastIndexOf = function(array, item, from) {
    if (array == null) return -1;
    var hasIndex = from != null;
    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
    }
    var i = (hasIndex ? from : array.length);
    while (i--) if (array[i] === item) return i;
    return -1;
  };

  // Generate an integer Array containing an arithmetic progression. A port of
  // the native Python `range()` function. See
  // [the Python documentation](http://docs.python.org/library/functions.html#range).
  _.range = function(start, stop, step) {
    if (arguments.length <= 1) {
      stop = start || 0;
      start = 0;
    }
    step = arguments[2] || 1;

    var len = Math.max(Math.ceil((stop - start) / step), 0);
    var idx = 0;
    var range = new Array(len);

    while(idx < len) {
      range[idx++] = start;
      start += step;
    }

    return range;
  };

  // Function (ahem) Functions
  // ------------------

  // Reusable constructor function for prototype setting.
  var ctor = function(){};

  // Create a function bound to a given object (assigning `this`, and arguments,
  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
  // available.
  _.bind = function(func, context) {
    var args, bound;
    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
    if (!_.isFunction(func)) throw new TypeError;
    args = slice.call(arguments, 2);
    return bound = function() {
      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
      ctor.prototype = func.prototype;
      var self = new ctor;
      ctor.prototype = null;
      var result = func.apply(self, args.concat(slice.call(arguments)));
      if (Object(result) === result) return result;
      return self;
    };
  };

  // Partially apply a function by creating a version that has had some of its
  // arguments pre-filled, without changing its dynamic `this` context.
  _.partial = function(func) {
    var args = slice.call(arguments, 1);
    return function() {
      return func.apply(this, args.concat(slice.call(arguments)));
    };
  };

  // Bind all of an object's methods to that object. Useful for ensuring that
  // all callbacks defined on an object belong to it.
  _.bindAll = function(obj) {
    var funcs = slice.call(arguments, 1);
    if (funcs.length === 0) throw new Error("bindAll must be passed function names");
    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
    return obj;
  };

  // Memoize an expensive function by storing its results.
  _.memoize = function(func, hasher) {
    var memo = {};
    hasher || (hasher = _.identity);
    return function() {
      var key = hasher.apply(this, arguments);
      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
    };
  };

  // Delays a function for the given number of milliseconds, and then calls
  // it with the arguments supplied.
  _.delay = function(func, wait) {
    var args = slice.call(arguments, 2);
    return setTimeout(function(){ return func.apply(null, args); }, wait);
  };

  // Defers a function, scheduling it to run after the current call stack has
  // cleared.
  _.defer = function(func) {
    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
  };

  // Returns a function, that, when invoked, will only be triggered at most once
  // during a given window of time. Normally, the throttled function will run
  // as much as it can, without ever going more than once per `wait` duration;
  // but if you'd like to disable the execution on the leading edge, pass
  // `{leading: false}`. To disable execution on the trailing edge, ditto.
  _.throttle = function(func, wait, options) {
    var context, args, result;
    var timeout = null;
    var previous = 0;
    options || (options = {});
    var later = function() {
      previous = options.leading === false ? 0 : new Date;
      timeout = null;
      result = func.apply(context, args);
    };
    return function() {
      var now = new Date;
      if (!previous && options.leading === false) previous = now;
      var remaining = wait - (now - previous);
      context = this;
      args = arguments;
      if (remaining <= 0) {
        clearTimeout(timeout);
        timeout = null;
        previous = now;
        result = func.apply(context, args);
      } else if (!timeout && options.trailing !== false) {
        timeout = setTimeout(later, remaining);
      }
      return result;
    };
  };

  // Returns a function, that, as long as it continues to be invoked, will not
  // be triggered. The function will be called after it stops being called for
  // N milliseconds. If `immediate` is passed, trigger the function on the
  // leading edge, instead of the trailing.
  _.debounce = function(func, wait, immediate) {
    var result;
    var timeout = null;
    return function() {
      var context = this, args = arguments;
      var later = function() {
        timeout = null;
        if (!immediate) result = func.apply(context, args);
      };
      var callNow = immediate && !timeout;
      clearTimeout(timeout);
      timeout = setTimeout(later, wait);
      if (callNow) result = func.apply(context, args);
      return result;
    };
  };

  // Returns a function that will be executed at most one time, no matter how
  // often you call it. Useful for lazy initialization.
  _.once = function(func) {
    var ran = false, memo;
    return function() {
      if (ran) return memo;
      ran = true;
      memo = func.apply(this, arguments);
      func = null;
      return memo;
    };
  };

  // Returns the first function passed as an argument to the second,
  // allowing you to adjust arguments, run code before and after, and
  // conditionally execute the original function.
  _.wrap = function(func, wrapper) {
    return function() {
      var args = [func];
      push.apply(args, arguments);
      return wrapper.apply(this, args);
    };
  };

  // Returns a function that is the composition of a list of functions, each
  // consuming the return value of the function that follows.
  _.compose = function() {
    var funcs = arguments;
    return function() {
      var args = arguments;
      for (var i = funcs.length - 1; i >= 0; i--) {
        args = [funcs[i].apply(this, args)];
      }
      return args[0];
    };
  };

  // Returns a function that will only be executed after being called N times.
  _.after = function(times, func) {
    return function() {
      if (--times < 1) {
        return func.apply(this, arguments);
      }
    };
  };

  // Object Functions
  // ----------------

  // Retrieve the names of an object's properties.
  // Delegates to **ECMAScript 5**'s native `Object.keys`
  _.keys = nativeKeys || function(obj) {
    if (obj !== Object(obj)) throw new TypeError('Invalid object');
    var keys = [];
    for (var key in obj) if (_.has(obj, key)) keys.push(key);
    return keys;
  };

  // Retrieve the values of an object's properties.
  _.values = function(obj) {
    var values = [];
    for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);
    return values;
  };

  // Convert an object into a list of `[key, value]` pairs.
  _.pairs = function(obj) {
    var pairs = [];
    for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);
    return pairs;
  };

  // Invert the keys and values of an object. The values must be serializable.
  _.invert = function(obj) {
    var result = {};
    for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;
    return result;
  };

  // Return a sorted list of the function names available on the object.
  // Aliased as `methods`
  _.functions = _.methods = function(obj) {
    var names = [];
    for (var key in obj) {
      if (_.isFunction(obj[key])) names.push(key);
    }
    return names.sort();
  };

  // Extend a given object with all the properties in passed-in object(s).
  _.extend = function(obj) {
    each(slice.call(arguments, 1), function(source) {
      if (source) {
        for (var prop in source) {
          obj[prop] = source[prop];
        }
      }
    });
    return obj;
  };

  // Return a copy of the object only containing the whitelisted properties.
  _.pick = function(obj) {
    var copy = {};
    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
    each(keys, function(key) {
      if (key in obj) copy[key] = obj[key];
    });
    return copy;
  };

   // Return a copy of the object without the blacklisted properties.
  _.omit = function(obj) {
    var copy = {};
    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
    for (var key in obj) {
      if (!_.contains(keys, key)) copy[key] = obj[key];
    }
    return copy;
  };

  // Fill in a given object with default properties.
  _.defaults = function(obj) {
    each(slice.call(arguments, 1), function(source) {
      if (source) {
        for (var prop in source) {
          if (obj[prop] === void 0) obj[prop] = source[prop];
        }
      }
    });
    return obj;
  };

  // Create a (shallow-cloned) duplicate of an object.
  _.clone = function(obj) {
    if (!_.isObject(obj)) return obj;
    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
  };

  // Invokes interceptor with the obj, and then returns obj.
  // The primary purpose of this method is to "tap into" a method chain, in
  // order to perform operations on intermediate results within the chain.
  _.tap = function(obj, interceptor) {
    interceptor(obj);
    return obj;
  };

  // Internal recursive comparison function for `isEqual`.
  var eq = function(a, b, aStack, bStack) {
    // Identical objects are equal. `0 === -0`, but they aren't identical.
    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
    if (a === b) return a !== 0 || 1 / a == 1 / b;
    // A strict comparison is necessary because `null == undefined`.
    if (a == null || b == null) return a === b;
    // Unwrap any wrapped objects.
    if (a instanceof _) a = a._wrapped;
    if (b instanceof _) b = b._wrapped;
    // Compare `[[Class]]` names.
    var className = toString.call(a);
    if (className != toString.call(b)) return false;
    switch (className) {
      // Strings, numbers, dates, and booleans are compared by value.
      case '[object String]':
        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
        // equivalent to `new String("5")`.
        return a == String(b);
      case '[object Number]':
        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
        // other numeric values.
        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
      case '[object Date]':
      case '[object Boolean]':
        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
        // millisecond representations. Note that invalid dates with millisecond representations
        // of `NaN` are not equivalent.
        return +a == +b;
      // RegExps are compared by their source patterns and flags.
      case '[object RegExp]':
        return a.source == b.source &&
               a.global == b.global &&
               a.multiline == b.multiline &&
               a.ignoreCase == b.ignoreCase;
    }
    if (typeof a != 'object' || typeof b != 'object') return false;
    // Assume equality for cyclic structures. The algorithm for detecting cyclic
    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
    var length = aStack.length;
    while (length--) {
      // Linear search. Performance is inversely proportional to the number of
      // unique nested structures.
      if (aStack[length] == a) return bStack[length] == b;
    }
    // Objects with different constructors are not equivalent, but `Object`s
    // from different frames are.
    var aCtor = a.constructor, bCtor = b.constructor;
    if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
                             _.isFunction(bCtor) && (bCtor instanceof bCtor))) {
      return false;
    }
    // Add the first object to the stack of traversed objects.
    aStack.push(a);
    bStack.push(b);
    var size = 0, result = true;
    // Recursively compare objects and arrays.
    if (className == '[object Array]') {
      // Compare array lengths to determine if a deep comparison is necessary.
      size = a.length;
      result = size == b.length;
      if (result) {
        // Deep compare the contents, ignoring non-numeric properties.
        while (size--) {
          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
        }
      }
    } else {
      // Deep compare objects.
      for (var key in a) {
        if (_.has(a, key)) {
          // Count the expected number of properties.
          size++;
          // Deep compare each member.
          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
        }
      }
      // Ensure that both objects contain the same number of properties.
      if (result) {
        for (key in b) {
          if (_.has(b, key) && !(size--)) break;
        }
        result = !size;
      }
    }
    // Remove the first object from the stack of traversed objects.
    aStack.pop();
    bStack.pop();
    return result;
  };

  // Perform a deep comparison to check if two objects are equal.
  _.isEqual = function(a, b) {
    return eq(a, b, [], []);
  };

  // Is a given array, string, or object empty?
  // An "empty" object has no enumerable own-properties.
  _.isEmpty = function(obj) {
    if (obj == null) return true;
    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
    for (var key in obj) if (_.has(obj, key)) return false;
    return true;
  };

  // Is a given value a DOM element?
  _.isElement = function(obj) {
    return !!(obj && obj.nodeType === 1);
  };

  // Is a given value an array?
  // Delegates to ECMA5's native Array.isArray
  _.isArray = nativeIsArray || function(obj) {
    return toString.call(obj) == '[object Array]';
  };

  // Is a given variable an object?
  _.isObject = function(obj) {
    return obj === Object(obj);
  };

  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
  each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
    _['is' + name] = function(obj) {
      return toString.call(obj) == '[object ' + name + ']';
    };
  });

  // Define a fallback version of the method in browsers (ahem, IE), where
  // there isn't any inspectable "Arguments" type.
  if (!_.isArguments(arguments)) {
    _.isArguments = function(obj) {
      return !!(obj && _.has(obj, 'callee'));
    };
  }

  // Optimize `isFunction` if appropriate.
  if (typeof (/./) !== 'function') {
    _.isFunction = function(obj) {
      return typeof obj === 'function';
    };
  }

  // Is a given object a finite number?
  _.isFinite = function(obj) {
    return isFinite(obj) && !isNaN(parseFloat(obj));
  };

  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
  _.isNaN = function(obj) {
    return _.isNumber(obj) && obj != +obj;
  };

  // Is a given value a boolean?
  _.isBoolean = function(obj) {
    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
  };

  // Is a given value equal to null?
  _.isNull = function(obj) {
    return obj === null;
  };

  // Is a given variable undefined?
  _.isUndefined = function(obj) {
    return obj === void 0;
  };

  // Shortcut function for checking if an object has a given property directly
  // on itself (in other words, not on a prototype).
  _.has = function(obj, key) {
    return hasOwnProperty.call(obj, key);
  };

  // Utility Functions
  // -----------------

  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
  // previous owner. Returns a reference to the Underscore object.
  _.noConflict = function() {
    root._ = previousUnderscore;
    return this;
  };

  // Keep the identity function around for default iterators.
  _.identity = function(value) {
    return value;
  };

  // Run a function **n** times.
  _.times = function(n, iterator, context) {
    var accum = Array(Math.max(0, n));
    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
    return accum;
  };

  // Return a random integer between min and max (inclusive).
  _.random = function(min, max) {
    if (max == null) {
      max = min;
      min = 0;
    }
    return min + Math.floor(Math.random() * (max - min + 1));
  };

  // List of HTML entities for escaping.
  var entityMap = {
    escape: {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
      '"': '&quot;',
      "'": '&#x27;',
      '/': '&#x2F;'
    }
  };
  entityMap.unescape = _.invert(entityMap.escape);

  // Regexes containing the keys and values listed immediately above.
  var entityRegexes = {
    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
  };

  // Functions for escaping and unescaping strings to/from HTML interpolation.
  _.each(['escape', 'unescape'], function(method) {
    _[method] = function(string) {
      if (string == null) return '';
      return ('' + string).replace(entityRegexes[method], function(match) {
        return entityMap[method][match];
      });
    };
  });

  // If the value of the named `property` is a function then invoke it with the
  // `object` as context; otherwise, return it.
  _.result = function(object, property) {
    if (object == null) return void 0;
    var value = object[property];
    return _.isFunction(value) ? value.call(object) : value;
  };

  // Add your own custom functions to the Underscore object.
  _.mixin = function(obj) {
    each(_.functions(obj), function(name){
      var func = _[name] = obj[name];
      _.prototype[name] = function() {
        var args = [this._wrapped];
        push.apply(args, arguments);
        return result.call(this, func.apply(_, args));
      };
    });
  };

  // Generate a unique integer id (unique within the entire client session).
  // Useful for temporary DOM ids.
  var idCounter = 0;
  _.uniqueId = function(prefix) {
    var id = ++idCounter + '';
    return prefix ? prefix + id : id;
  };

  // By default, Underscore uses ERB-style template delimiters, change the
  // following template settings to use alternative delimiters.
  _.templateSettings = {
    evaluate    : /<%([\s\S]+?)%>/g,
    interpolate : /<%=([\s\S]+?)%>/g,
    escape      : /<%-([\s\S]+?)%>/g
  };

  // When customizing `templateSettings`, if you don't want to define an
  // interpolation, evaluation or escaping regex, we need one that is
  // guaranteed not to match.
  var noMatch = /(.)^/;

  // Certain characters need to be escaped so that they can be put into a
  // string literal.
  var escapes = {
    "'":      "'",
    '\\':     '\\',
    '\r':     'r',
    '\n':     'n',
    '\t':     't',
    '\u2028': 'u2028',
    '\u2029': 'u2029'
  };

  var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;

  // JavaScript micro-templating, similar to John Resig's implementation.
  // Underscore templating handles arbitrary delimiters, preserves whitespace,
  // and correctly escapes quotes within interpolated code.
  _.template = function(text, data, settings) {
    var render;
    settings = _.defaults({}, settings, _.templateSettings);

    // Combine delimiters into one regular expression via alternation.
    var matcher = new RegExp([
      (settings.escape || noMatch).source,
      (settings.interpolate || noMatch).source,
      (settings.evaluate || noMatch).source
    ].join('|') + '|$', 'g');

    // Compile the template source, escaping string literals appropriately.
    var index = 0;
    var source = "__p+='";
    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
      source += text.slice(index, offset)
        .replace(escaper, function(match) { return '\\' + escapes[match]; });

      if (escape) {
        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
      }
      if (interpolate) {
        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
      }
      if (evaluate) {
        source += "';\n" + evaluate + "\n__p+='";
      }
      index = offset + match.length;
      return match;
    });
    source += "';\n";

    // If a variable is not specified, place data values in local scope.
    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';

    source = "var __t,__p='',__j=Array.prototype.join," +
      "print=function(){__p+=__j.call(arguments,'');};\n" +
      source + "return __p;\n";

    try {
      render = new Function(settings.variable || 'obj', '_', source);
    } catch (e) {
      e.source = source;
      throw e;
    }

    if (data) return render(data, _);
    var template = function(data) {
      return render.call(this, data, _);
    };

    // Provide the compiled function source as a convenience for precompilation.
    template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';

    return template;
  };

  // Add a "chain" function, which will delegate to the wrapper.
  _.chain = function(obj) {
    return _(obj).chain();
  };

  // OOP
  // ---------------
  // If Underscore is called as a function, it returns a wrapped object that
  // can be used OO-style. This wrapper holds altered versions of all the
  // underscore functions. Wrapped objects may be chained.

  // Helper function to continue chaining intermediate results.
  var result = function(obj) {
    return this._chain ? _(obj).chain() : obj;
  };

  // Add all of the Underscore functions to the wrapper object.
  _.mixin(_);

  // Add all mutator Array functions to the wrapper.
  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
    var method = ArrayProto[name];
    _.prototype[name] = function() {
      var obj = this._wrapped;
      method.apply(obj, arguments);
      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
      return result.call(this, obj);
    };
  });

  // Add all accessor Array functions to the wrapper.
  each(['concat', 'join', 'slice'], function(name) {
    var method = ArrayProto[name];
    _.prototype[name] = function() {
      return result.call(this, method.apply(this._wrapped, arguments));
    };
  });

  _.extend(_.prototype, {

    // Start chaining a wrapped Underscore object.
    chain: function() {
      this._chain = true;
      return this;
    },

    // Extracts the result from a wrapped and chained object.
    value: function() {
      return this._wrapped;
    }

  });

}).call(this);


================================================
FILE: vendors/firmcard/test/FirmCardSpec.html
================================================
<!doctype html>
<html>
<head>
    <meta charset="utf-8">
    <link rel="stylesheet" href="mocha.css">
</head>

<body>
    <script src="sinon.js"></script>
    <script src="mocha.js"></script>
    <script src="../src/vendors/underscore1.5.1.js"></script>
    <script src="expect.js"></script>


    <script src="../src/FirmCard.js"></script>
    <script src="../src/FirmCard.DataHelper.js"></script>

    <script src="../src/Schedule.js"></script>
    <script src="../src/Dictionary.js"></script>

    <script type="text/javascript">
        mocha.setup('bdd');
        mocha.ignoreLeaks();
    </script>

    <div id="mocha"></div>

    <script src="demoData.js"></script>
    <script src="FirmCardSpec.js"></script>
    <script type="text/javascript">
        mocha.run();
    </script>
</body>
</html>


================================================
FILE: vendors/firmcard/test/FirmCardSpec.js
================================================
describe('Расписание работы организации', function () {

    function mockTime(timestamp) {
        //rid of magic 6 (local time)
        return timestamp + (7 + new Date().getTimezoneOffset() / 60) * 60 * 60 * 1000;
    }
    var d = new FirmCard(null, {
        localLang: 'ru'
    });

    it('!model', function () {
        var result =  d.getSchedule().transform();

        expect(result).to.not.be.ok();
    });

    it('!params', function () {
        var result =  d.getSchedule().transform(scheduleDemoData['default'].model);

        expect(result).to.be.ok();
        expect(result.everyday).to.not.be.ok();

    });

    it('Comment', function () {
        var result =  d.getSchedule().transform({
            comment: 'comment'
        });

        expect(result.comment).to.be('comment');
        expect(result.everyday).to.be.ok(); // Ежедневно закрыто, Ха!

    });

    it('Будни одинаково, выходные выходные', function () {
        var result =  d.getSchedule().transform(scheduleDemoData['default'].model, {
            now: mockTime(1366610753162),

        }); // 13:06 пн 22 апреля 2013
        expect(result.now.open).to.be.ok();
        expect(result.will.d).to.be(0);
        expect(result.will.h).to.be(4);
        expect(result.will.m).to.be(50);
        expect(result.will.till).to.be('18:00');
        expect(result.today.from).to.be('10:00');
        expect(result.today.to).to.be('18:00');
        expect(result.week.evently[0].dayList).to.be('Понедельник–пятница');
        expect(result.week.evently[0].budni).to.be.ok();
        expect(result.week.evently[0].everyday).to.not.be.ok();
        expect(result.week.evently[1].dayList).to.be('Суббота, воскресенье');
        expect(result.week.evently[1].budni).to.not.be.ok();
        expect(result.week.evently[1].everyday).to.not.be.ok();
        expect(result.everyday).to.not.be.ok();

    });

    it('Будни одинаково, выходные выходные, до нуля', function () {
        var result =  d.getSchedule().transform(scheduleDemoData.evently.model, {
            now: mockTime(1366610753162)
        }); // 13:06 пн 22 апреля 2013


        expect(result.now.open).to.be.ok();
        expect(result.will.d).to.be(0);
        expect(result.will.h).to.be(10);
        expect(result.will.m).to.be(50);
        expect(result.will.till).to.be('00:00');
        expect(result.today.from).to.be('10:00');
        expect(result.today.to).to.be('00:00');
        expect(result.week.evently[0].dayList).to.be('Понедельник–пятница');
        expect(result.week.evently[0].budni).to.be.ok();
        expect(result.week.evently[0].holiday).to.not.be.ok();
        expect(result.week.evently[0].everyday).to.not.be.ok();
        expect(result.week.evently[1].dayList).to.be('Суббота, воскресенье');
        expect(result.week.evently[1].budni).to.not.be.ok();
        expect(result.week.evently[1].holiday).to.be.ok();
        expect(result.week.evently[1].everyday).to.not.be.ok();
        expect(result.everyday).to.not.be.ok();

    });

    it('Будни одинаково, суббота сокращённо', function () {
        var result =  d.getSchedule().transform(scheduleDemoData.eventlySat.model, {
            now: mockTime(1366610753162)
        }); // 13:06 пн 22 апреля 2013

        expect(result.now.open).to.be.ok();
        expect(result.will.d).to.be(0);
        expect(result.will.h).to.be(4);
        expect(result.will.m).to.be(50);
        expect(result.will.till).to.be('18:00');
        expect(result.today.from).to.be('10:00');
        expect(result.today.to).to.be('18:00');
        expect(result.week.evently).to.not.be.ok;
        expect(_.isEqual(result.week.table, [
            { from: '10:00', to: '18:00', lunch: [], active: true, key: 'пнд' },
            { from: '10:00', to: '18:00', lunch: [], key: 'втр' },
            { from: '10:00', to: '18:00', lunch: [], key: 'срд' },
            { from: '10:00', to: '18:00', lunch: [], key: 'чтв' },
            { from: '10:00', to: '18:00', lunch: [], key: 'птн' },
            { from: '10:00', to: '17:00', lunch: [], key: 'сбт' },
            { key: 'вск' }
        ])).to.be.ok;
        expect(result.everyday).to.not.be.ok();

    });

    it('Будни одинаково, суббота сокращённо, максимум часов в субботу', function () {
        var result =  d.getSchedule().transform(scheduleDemoData.eventlySatMax.model, {
            now: mockTime(1366610753162)
        }); // 13:06 пн 22 апреля 2013

        expect(result.now.open).to.be.ok();
        expect(result.will.d).to.be(0);
        expect(result.will.h).to.be(4);
        expect(result.will.m).to.be(50);
        expect(result.will.till).to.be('18:00');
        expect(result.today.from).to.be('10:00');
        expect(result.today.to).to.be('18:00');
        expect(result.week.evently).to.not.be.ok;
        expect(_.isEqual(result.week.table, [
            { from: '10:00', to: '18:00', lunch: [], active: true, key: 'пнд' },
            { from: '10:00', to: '18:00', lunch: [], key: 'втр' },
            { from: '10:00', to: '18:00', lunch: [], key: 'срд' },
            { from: '10:00', to: '18:00', lunch: [], key: 'чтв' },
            { from: '10:00', to: '18:00', lunch: [], key: 'птн' },
            { from: '10:00', to: '19:00', lunch: [], key: 'сбт' },
            { key: 'вск' }
        ])).to.be.ok;
        expect(result.everyday).to.not.be.ok();
    });

    it('Круглосуточно без выходных', function () {
        var result =  d.getSchedule().transform(scheduleDemoData.alltime.model, {
            now: mockTime(1366610753162)
        }); // 13:06 пн 22 апреля 2013

        expect(result.now.open).to.be.ok();
        expect(result.always).to.be.ok();
        expect(result.today.alltime).to.be.ok();
        expect(result.will).to.not.be.ok();
        expect(result.week.hasLunch).to.not.be.ok();
        expect(result.week.evently[0].dayList).to.be('Понедельник, вторник, среда, четверг, пятница, суббота, воскресенье');
        expect(result.week.evently[0].alltime).to.be.ok();
        expect(result.week.evently[0].budni).to.not.be.ok();
        expect(result.week.evently[0].everyday).to.be.ok();
        expect(result.everyday).to.be.ok();

    });

    it('Круглосуточно кроме выходных среды и воскресенья', function () {
        var result =  d.getSchedule().transform(scheduleDemoData.thuHol.model, {
            now: mockTime(1366610753162)
        }); // 13:06 пн 22 апреля 2013

        expect(result.now.open).to.be.ok();
        expect(result.always).to.be(undefined);
        expect(result.today.alltime).to.be.ok();
        expect(result.will.d).to.be(2);
        expect(result.will.h).to.be(58);
        expect(result.will.m).to.be(50);
        expect(result.will.till).to.be('00:00');
        expect(result.week.hasLunch).to.not.be.ok();
        expect(result.week.evently[0].dayList).to.be('Понедельник–среда, пятница, суббота');
        expect(result.week.evently[0].alltime).to.be.ok();
        expect(result.week.evently[0].budni).to.not.be.ok();
        expect(result.week.evently[0].everyday).to.not.be.ok();
        expect(result.week.evently[1].dayList).to.be('Четверг, воскресенье');
        expect(result.week.evently[1].alltime).to.not.be.ok();
        expect(result.week.evently[1].budni).to.not.be.ok();
        expect(result.week.evently[1].everyday).to.not.be.ok();
        expect(result.everyday).to.not.be.ok();

    });

    it('Среда–пятница', function () {
        var result =  d.getSchedule().transform(scheduleDemoData.strangeWeek.model, {
            now: mockTime(1366610753162)
        }); // 13:06 пн 22 апреля 2013

        expect(result.now.open).to.not.be.ok();
        expect(result.always).to.be(undefined);
        expect(result.today).to.be(undefined);
        expect(result.will.d).to.be(2);
        expect(result.will.h).to.be(34);
        expect(result.will.m).to.be(50);
        expect(result.will.when).to.be('в среду');
        expect(result.will.till).to.be('00:00');
        expect(result.week.hasLunch).to.not.be.ok();
        expect(result.week.evently[0].dayList).to.be('Среда–пятница');
        expect(result.week.evently[0].alltime).to.be(undefined);
        expect(result.week.evently[0].everyday).to.not.be.ok();
        expect(result.week.evently[0].budni).to.not.be.ok();
        expect(result.week.evently[1].dayList).to.be('Понедельник, вторник, суббота, воскресенье');
        expect(result.week.evently[1].alltime).to.not.be.ok();
        expect(result.week.evently[1].everyday).to.not.be.ok();
        expect(result.week.evently[1].budni).to.not.be.ok();
        expect(result.everyday).to.not.be.ok();

    });

    it('Работает только в воскресенье с обедом', function () {
        var result =  d.getSchedule().transform(scheduleDemoData.periods3.model, {
            now: mockTime(1366610753162)
        }); // 13:06 пн 22 апреля 2013

        expect(result.now.open).to.not.be.ok();
        expect(result.always).to.be(undefined);
        expect(result.today).to.be(undefined);
        expect(result.will.d).to.be(6);
        expect(result.will.h).to.be(140);
        expect(result.will.m).to.be(50);
        expect(result.will.when).to.be('в воскресенье');
        expect(result.will.till).to.be('10:00');
        expect(result.week.hasLunch).to.not.be.ok();
        expect(result.week.evently[0].dayList).to.be('Воскресенье');
        expect(result.week.evently[0].alltime).to.be(undefined);
        expect(result.week.evently[0].everyday).to.not.be.ok();
        expect(result.week.evently[0].budni).to.not.be.ok();
        expect(result.week.evently[1].dayList).to.be('Понедельник–суббота');
        expect(result.week.evently[1].alltime).to.not.be.ok();
        expect(result.week.evently[1].everyday).to.not.be.ok();
        expect(result.week.evently[1].budni).to.not.be.ok();
        expect(result.everyday).to.not.be.ok();

    });

    it('Закроется через 1 минуту', function () {
        var result =  d.getSchedule().transform(scheduleDemoData.oneMinuteLeft.model, {
            now: mockTime(1366610753162)
        }); // 13:06 пн 22 апреля 2013

        expect(result.now.open).to.be.ok();
        expect(result.always).to.be(undefined);
        expect(result.today).to.be.ok();
        expect(result.will.d).to.be(0);
        expect(result.will.h).to.be(0);
        expect(result.will.m).to.be(5);

    });

    it('Сегодня уже закрыто, откроется через неделю', function () {
        var result =  d.getSchedule().transform(scheduleDemoData.foraWeek.model, {
            now: mockTime(1366610753162)
        }); // 13:06 пн 22 апреля 2013

        expect(result.now.open).to.not.be.ok();
        expect(result.always).to.be(undefined);
        expect(result.today).to.be.ok();
        expect(result.will.d).to.be(7);
        expect(result.will.h).to.be(165);
        expect(result.will.m).to.be(20);
        expect(result.everyday).to.not.be.ok();

    });

    it('Ещё закрыто, откроется через час с лишним', function () {
        var result =  d.getSchedule().transform(scheduleDemoData.tooEarly.model, {
            now: mockTime(1366773607003)
        }); // 10:20 ср 24 апреля 2013

        expect(result.now.open).to.not.be.ok();
        expect(result.always).to.be(undefined);
        expect(result.today).to.be.ok();
        expect(result.will.d).to.be(0);
        expect(result.will.h).to.be(1);
        expect(result.will.m).to.be(40);
        expect(result.will.when).to.be(undefined);
        expect(result.comment).to.ok('до последнего клиента');

    });

    it('Откроется завтра если сегодня воскресенье', function () { // Баг сбербанка
        var result =  d.getSchedule().transform(scheduleDemoData.sberBank.model, {
            now: mockTime(1367138129777)
        }); // Воскресенье, 28 апреля 2013

        expect(result.will.d).to.be(1);
        expect(result.will.when).to.be('завтра');
        expect(result.everyday).to.not.be.ok();

    });

    it('Ежедневно одинаково, откроется завтра', function () { // Баг с неправильной сортировкой timestamps
        var result =  d.getSchedule().transform(scheduleDemoData.everyday.model, {
            now: mockTime(1368015897543)
        }); // Среда, 8 мая 2013, 19+

        expect(result.will.d).to.be(1);
    });

    it('Timespamp совпадает с открытием – должен быть объект will', function () { // Баг с неправильной сортировкой timestamps
        var result =  d.getSchedule().transform(scheduleDemoData.everyday.model, {
            now: mockTime(1368015897543 + 52560000)
        }); // Точно совпадает с временем открытия

        expect(result.will).to.be.ok();
    });
});

describe('FirmCard', function () {

    it('При повторном render ajax не вызывается', function () {
        var render = sinon.stub(FirmCard.prototype, '_renderCardById', function (firmId) {
                this._firmId = firmId;
                this.options.ajax();
            }),
            ajaxSpy = sinon.spy(function () {
                firmCard._fullFirmEl = document.createElement('div');
            }),
            firmCard = new FirmCard(undefined,
            {
                ajax: ajaxSpy,
                tmpls: {
                    loader: ''
                },
                render: function () {return ''; }
            });

        firmCard.render('141265770546806');
        firmCard.render('141265770546806');

       expect(ajaxSpy.callCount).to.be.eql(1);

       render.restore();

    });

    it('#getSchedule возвращает объект типа FirmCard.Schedule', function () {
        var firmCard = new FirmCard();

        expect(firmCard.getSchedule()).to.be.a(FirmCard.Schedule);
    });

});


================================================
FILE: vendors/firmcard/test/FirmListSpec.html
================================================
<!doctype html>
<html>
<head>
    <meta charset="utf-8">
    <link rel="stylesheet" href="mocha.css">
</head>

<body>
    <script src="mocha.js"></script>
    <script src="sinon.js"></script>
    <script src="expect.js"></script>

    <script src="../src/FirmCard.js"></script>
    <script src="../src/FirmCard.DataHelper.js"></script>
    <script src="../src/FirmList.js"></script>

    <script src="../src/Schedule.js"></script>
    <script src="../src/Dictionary.js"></script>

    <script type="text/javascript">
        mocha.setup('bdd');
        mocha.ignoreLeaks();
    </script>

    <div id="mocha"></div>

    <script src="FirmListSpec.js"></script>
    <script type="text/javascript">
        mocha.run();
    </script>
</body>
</html>


================================================
FILE: vendors/firmcard/test/FirmListSpec.js
================================================
describe('DGFirmList', function () {
    var render, results, addFirms, alreadyInList, defaultFirm;
    beforeEach(function () {
        results =
        [{"id":"141265769760312_7f48jh2915H23H8he2g3uvDn5A6AG45842cB44287906231J5b6d19G4H3G38495","name":"Спарк-Авто, ООО","type":"filial","firm":{"id":"141274359477657","filials_count":3,"name":"Спарк-Авто, ООО"},"ads":{"warning":null,"micro_comment":"Оригинальные и дубликатные запчасти на авто европейского производства"},"rubrics":{"primary":[{"name":"Автозапчасти для иномарок"},{"name":"Автохимия / Масла"},{"name":"Автоаксессуары"}],"additional":[]}},{"id":"141265769349900_71B8jh2903H33H75e5BguvDn5A6AG45842cB4428379C231J546A19G4H3G28495","name":"Автозапчасти, ООО Невис ПТ","type":"filial","firm":{"id":"141274359268956","filials_count":1,"name":"Автозапчасти, ООО Невис ПТ"},"ads":null,"rubrics":{"primary":[{"name":"Автозапчасти для иномарок"},{"name":"Автоаксессуары"}],"additional":[]}},{"id":"141265769369916_77A8jh2919H43H6ee45BuvDn5A6AG4584AcB4428399C231J556719G4H3G28495","name":"Детская поликлиника, Детская городская клиническая больница №1, Отделение №2","type":"filial","firm":{"id":"141274359278970","filials_count":2,"name":"Детская поликлиника, Детская городская клиническая больница №1"},"ads":null,"rubrics":{"primary":[{"name":"Поликлиники детские"}],"additional":[]}},{"id":"141265770849956_7A88jh2959H53H78e9g9uvDn5A71G4584ecB4428879C231J5b6919G4H3G28495","name":"Магазин автозапчастей для Peugeot, Citroen, Fiat, ООО Меркурий Авто","type":"filial","firm":{"id":"141274359990712","filials_count":1,"name":"Магазин автозапчастей для Peugeot, Citroen, Fiat, ООО Меркурий Авто"},"ads":null,"rubrics":{"primary":[{"name":"Автозапчасти для иномарок"}],"additional":[]}}];
        addFirms = [{"id":"141265770537261_gb48jh2964H43HA6b42guvDn5A71G4584gh744285675535JA18g19G4H3G28816","name":"Семицветик, АНО, центр развития ребенка","type":"filial","firm":{"id":"141274359781129","filials_count":4,"name":"Семицветик, АНО, центр развития ребенка"},"ads":null,"rubrics":{"primary":[{"name":"Центры раннего развития / дошкольного образования детей"}],"additional":[]}},{"id":"141265771201116_eb4Cjh2919H53HA5b66guvDn5A72G45876g744282314535JA18g19G4H3G28816","name":"СибТайм, лингвистический центр","type":"filial","firm":{"id":"141274359311404","filials_count":4,"name":"СибТайм, лингвистический центр"},"ads":null,"rubrics":{"primary":[{"name":"Школы иностранных языков"}],"additional":[{"name":"Перевод с иностранных языков"},{"name":"Обучение за рубежом"}]}},{"id":"141265770296136_2b49jh2939H63H87beeguvDn5A71G458b87744282C64535J918g19G4H3G28816","name":"Пеликан, центр психолого-педагогической поддержки молодежи","type":"filial","firm":{"id":"141274359390966","filials_count":2,"name":"Пеликан, центр психолого-педагогической поддержки молодежи"},"ads":null,"rubrics":{"primary":[{"name":"Услуги психолога"}],"additional":[]}},{"id":"141265770029779_1b4hjh297CH73H95b6cguvDn5A71G4583A574428059A535J218g19G4H3G28816","name":"Следственный отдел по Кировскому району","type":"filial","firm":{"id":"141274359738445","filials_count":1,"name":"Следственный отдел по Кировскому району"},"ads":null,"rubrics":{"primary":[{"name":"Следственный комитет"}],"additional":[]}}];
        alreadyInList = [{"id":"141265769760312_7f48jh2915H23H8he2g3uvDn5A6AG45842cB44287906231J5b6d19G4H3G38495","name":"Спарк-Авто, ООО","type":"filial","firm":{"id":"141274359477657","filials_count":3,"name":"Спарк-Авто, ООО"},"ads":{"warning":null,"micro_comment":"Оригинальные и дубликатные запчасти на авто европейского производства"},"rubrics":{"primary":[{"name":"Автозапчасти для иномарок"},{"name":"Автохимия / Масла"},{"name":"Автоаксессуары"}],"additional":[]}}];
        defaultFirm = {"id":"141265769358463_1b4ijh2966H23H97b37guvDn5A6AG4589d9744283887535JB18g19G4H3G28816","name":"Железобетонспецстрой, ЗАО, строительная компания","type":"filial","firm":{"id":"141274359275268","filials_count":1,"name":"Железобетонспецстрой, ЗАО, строительная компания"},"ads":null,"rubrics":{"primary":[{"name":"Реконструкция и капремонт зданий"},{"name":"Промышленное строительство"},{"name":"Жилищное строительство"}],"additional":[]}};
    });

    afterEach(function () {
        results = addFirms = alreadyInList = defaultFirm = null;
    });

    describe('#should set correct default options:', function () {
        it("default container", function() {
            var firmList = new FirmCard.List(results, {});

            expect(firmList.getContainer().className).to.be('dg-building-callout__list');
        });

        it("default lang = ru", function() {
            var firmList = new FirmCard.List(results, {});

            expect(firmList.getLang()).to.be('ru');
        });
    })

    describe('#should manage FirmCards in correct way:', function () {
        it("render results and return FirmList container", function() {
            var customContainer = document.createElement('div'),
                firmList = new FirmCard.List(results, {container: customContainer});

            expect(customContainer.className).to.be('dg-building-callout__list');
            expect(customContainer.querySelectorAll('.dg-building-callout__list-item').length).to.be(4);
        });

        it("add firm", function() {
            var customContainer = document.createElement('div'),
                firmList = new FirmCard.List(results, {container: customContainer});
            firmList.addFirms(defaultFirm);
            firmList.renderList();

            expect(customContainer.querySelectorAll('.dg-building-callout__list-item').length).to.be(5);
        });

        it("add firms array", function() {
            var customContainer = document.createElement('div'),
                firmList = new FirmCard.List(results, {container: customContainer});
            firmList.addFirms(addFirms);
            firmList.renderList();

            expect(customContainer.querySelectorAll('.dg-building-callout__list-item').length).to.be(8);
        });

        it("remove firm", function() {
            var customContainer = document.createElement('div'),
                firmList = new FirmCard.List(results, {container: customContainer});
            firmList.removeFirms('141265769760312');

            expect(customContainer.querySelector('#firm-141265769760312')).not.to.be.ok();
            expect(customContainer.querySelectorAll('.dg-building-callout__list-item').length).to.be(3);
        });

        it("remove firms array", function() {
            var customContainer = document.createElement('div'),
                firmList = new FirmCard.List(results, {container: customContainer});
            firmList.renderList();
            firmList.removeFirms(['141265769760312', '141265769349900', '141265770849956']);

            expect(customContainer.querySelectorAll('.dg-building-callout__list-item').length).to.be(1);
        });

        it("remove firms if List was cleared", function() {
            var customContainer = document.createElement('div'),
                firmList = new FirmCard.List(results, {container: customContainer});
            firmList.renderList();
            firmList.clearList();

            expect(customContainer.querySelectorAll('.dg-building-callout__list-item').length).to.be(0);
        });

        it("ignore firm if it already in list", function() {
            var customContainer = document.createElement('div'),
                firmList = new FirmCard.List(results, {container: customContainer});
            firmList.renderList();
            firmList.addFirms(alreadyInList);
            firmList.renderList();

            expect(customContainer.querySelectorAll('.dg-building-callout__list-item').length).to.be(4);
        });
    })

    describe('#should support localization:', function () {
        it("setLang method", function() {
            var firmList = new FirmCard.List(results, {});
            firmList.setLang('en');
            expect(firmList.getLang()).to.be('en');
        });
    })
});


================================================
FILE: vendors/firmcard/test/demoData.js
================================================
var scheduleDemoData = {

    // Будни одинаково, выходные выходные
    default: {
        model: {
            "Mon": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Tue": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Wed": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Thu": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Fri": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "comment": null
        }
    },

    // Ежедневно одинаково
    everyday: {
        model: {
            "Mon": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Tue": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Wed": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Thu": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Fri": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Sat": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Sun": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "comment": null
        }
    },

    // До нуля
    evently: {
        model: {
            "Mon": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "00:00"
                }]
            },
            "Tue": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "00:00"
                }]
            },
            "Wed": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "00:00"
                }]
            },
            "Thu": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "00:00"
                }]
            },
            "Fri": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "00:00"
                }]
            },
            "comment": null
        }
    },

    // Будни одинаково, суббота сокращённо
    eventlySat: {
        model: {
            "Mon": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Tue": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Wed": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Thu": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Fri": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Sat": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "17:00"
                }]
            },
            "comment": null
        }
    },

    // Максимум часов в субботу
    eventlySatMax: {
        model: {
            "Mon": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Tue": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Wed": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Thu": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Fri": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "18:00"
                }]
            },
            "Sat": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "19:00"
                }]
            },
            "comment": null
        }
    },

    // Круглосуточно без выходных
    alltime: {
        model: {
            "Mon": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "Tue": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "Wed": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "Thu": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "Fri": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "Sat": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "Sun": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "comment": null
        }
    },

    // Круглосуточно кроме выходных среды и воскресенья
    thuHol: {
        model: {
            "Mon": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "Tue": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "Wed": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "Fri": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "Sat": {
                "round_the_clock": true,
                "working_hours": [{
                    "from": "00:00",
                    "to": "00:00"
                }]
            },
            "comment": null
        }
    },

    // Будни, начало недели во вторник, рабочая среда-пятница
    strangeWeek: {
        model: {
            "Wed": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "00:00",
                    "to": "23:00"
                }]
            },
            "Thu": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "00:00",
                    "to": "23:00"
                }]
            },
            "Fri": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "00:00",
                    "to": "23:00"
                }]
            },
            "comment": null
        }
    },

    // Пон-среда, пятница-воскресенье больше часов
    periods2: {
        model: {
            "Mon": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "18:00"
                }]
            },
            "Tue": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "18:00"
                }]
            },
            "Wed": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "18:00"
                }]
            },
            "Fri": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "19:00"
                }]
            },
            "Sat": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "19:00"
                }]
            },
            "Sun": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "19:00"
                }]
            },
            "comment": null
        }
    },

    //
    periods3: {
        model: {
            "Sun": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "19:00"
                }]
            },
            "comment": null
        }
    },

    oneMinuteLeft: {
        model: {
            "Mon": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:06"
                }]
            },
            "comment": null
        }
    },

    foraWeek: {
        model: {
            "Mon": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:31",
                    "to": "13:05"
                }]
            },
            "comment": null
        }
    },

    // Много обедов
    lunches: {
        model: {
            "Mon": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "15:00"
                }, {
                    "from": "16:00",
                    "to": "18:00"
                }]
            },
            "Tue": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "15:00"
                }, {
                    "from": "16:00",
                    "to": "18:00"
                }]
            },
            "Wed": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "15:00"
                }, {
                    "from": "16:00",
                    "to": "18:00"
                }]
            },
            "Fri": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "15:00"
                }, {
                    "from": "16:00",
                    "to": "18:00"
                }]
            },
            "Sat": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "16:00",
                    "to": "18:00"
                }]
            },
            "Sun": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "13:00"
                }, {
                    "from": "14:00",
                    "to": "15:00"
                }, {
                    "from": "16:00",
                    "to": "18:00"
                }]
            },
            "comment": null
        }
    },

    night: {
        model: {
            "Mon": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "05:00"
                }]
            },
            "Tue": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "01:00"
                }]
            },
            "Wed": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "02:00"
                }]
            },
            "Fri": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "04:00"
                }]
            },
            "Sat": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "17:00"
                }, {
                    "from": "18:00",
                    "to": "04:00"
                }]
            },
            "Sun": {
                "round_the_clock": false,
                "working_hours": [{
                    "from": "10:00",
                    "to": "04:00"
                }]
            },
            "comment": null
        }
    },

    tooEarly: {
        model: {
            Mon: {
                round_the_clock: false,
                working_hours: [{
                    from: "12:00",
                    to: "00:00"
                }]
            },
            Tue: {
                round_the_clock: false,
                working_hours: [{
                    from: "12:00",
                    to: "00:00"
                }]
            },
            Wed: {
                round_the_clock: false,
                working_hours: [{
                    from: "12:00",
                    to: "00:00"
                }]
            },
            Thu: {
                round_the_clock: false,
                working_hours: [{
                    from: "12:00",
                    to: "00:00"
                }]
            },
            Fri: {
                round_the_clock: false,
                working_hours: [{
                    from: "12:00",
                    to: "00:00"
                }]
            },
            Sat: {
                round_the_clock: false,
                working_hours: [{
                    from: "12:00",
                    to: "00:00"
                }]
            },
            Sun: {
                round_the_clock: false,
                working_hours: [{
                    from: "12:00",
                    to: "00:00"
                }]
            },
            comment: "до последнего клиента"
        }
    },

    sberBank: {
        model: {
            Mon: {
                round_the_clock: false,
                working_hours: [{
                    from: "09:00",
                    to: "19:00"
                }]
            },
            Tue: {
                round_the_clock: false,
                working_hours: [{
                    from: "09:00",
                    to: "19:00"
                }]
            },
            Wed: {
                round_the_clock: false,
                working_hours: [{
                    from: "09:00",
                    to: "19:00"
                }]
            },
            Thu: {
                round_the_clock: false,
                working_hours: [{
                    from: "09:00",
                    to: "19:00"
                }]
            },
            Fri: {
                round_the_clock: false,
                working_hours: [{
                    from: "09:00",
                    to: "19:00"
                }]
            },
            Sat: {
                round_the_clock: false,
                working_hours: [{
                    from: "10:00",
                    to: "16:00"
                }]
            },
            Sun: null,
            comment: null
        }
    }
};


================================================
FILE: vendors/firmcard/test/expect.js
================================================

(function (global, module) {

  if ('undefined' == typeof module) {
    var module = { exports: {} }
      , exports = module.exports
  }

  /**
   * Exports.
   */

  module.exports = expect;
  expect.Assertion = Assertion;

  /**
   * Exports version.
   */

  expect.version = '0.1.2';

  /**
   * Possible assertion flags.
   */

  var flags = {
      not: ['to', 'be', 'have', 'include', 'only']
    , to: ['be', 'have', 'include', 'only', 'not']
    , only: ['have']
    , have: ['own']
    , be: ['an']
  };

  function expect (obj) {
    return new Assertion(obj);
  }

  /**
   * Constructor
   *
   * @api private
   */

  function Assertion (obj, flag, parent) {
    this.obj = obj;
    this.flags = {};

    if (undefined != parent) {
      this.flags[flag] = true;

      for (var i in parent.flags) {
        if (parent.flags.hasOwnProperty(i)) {
          this.flags[i] = true;
        }
      }
    }

    var $flags = flag ? flags[flag] : keys(flags)
      , self = this

    if ($flags) {
      for (var i = 0, l = $flags.length; i < l; i++) {
        // avoid recursion
        if (this.flags[$flags[i]]) continue;

        var name = $flags[i]
          , assertion = new Assertion(this.obj, name, this)

        if ('function' == typeof Assertion.prototype[name]) {
          // clone the function, make sure we dont touch the prot reference
          var old = this[name];
          this[name] = function () {
            return old.apply(self, arguments);
          }

          for (var fn in Assertion.prototype) {
            if (Assertion.prototype.hasOwnProperty(fn) && fn != name) {
              this[name][fn] = bind(assertion[fn], assertion);
            }
          }
        } else {
          this[name] = assertion;
        }
      }
    }
  };

  /**
   * Performs an assertion
   *
   * @api private
   */

  Assertion.prototype.assert = function (truth, msg, error) {
    var msg = this.flags.not ? error : msg
      , ok = this.flags.not ? !truth : truth;

    if (!ok) {
      throw new Error(msg.call(this));
    }

    this.and = new Assertion(this.obj);
  };

  /**
   * Check if the value is truthy
   *
   * @api public
   */

  Assertion.prototype.ok = function () {
    this.assert(
        !!this.obj
      , function(){ return 'expected ' + i(this.obj) + ' to be truthy' }
      , function(){ return 'expected ' + i(this.obj) + ' to be falsy' });
  };

  /**
   * Assert that the function throws.
   *
   * @param {Function|RegExp} callback, or regexp to match error string against
   * @api public
   */

  Assertion.prototype.throwError =
  Assertion.prototype.throwException = function (fn) {
    expect(this.obj).to.be.a('function');

    var thrown = false
      , not = this.flags.not

    try {
      this.obj();
    } catch (e) {
      if ('function' == typeof fn) {
        fn(e);
      } else if ('object' == typeof fn) {
        var subject = 'string' == typeof e ? e : e.message;
        if (not) {
          expect(subject).to.not.match(fn);
        } else {
          expect(subject).to.match(fn);
        }
      }
      thrown = true;
    }

    if ('object' == typeof fn && not) {
      // in the presence of a matcher, ensure the `not` only applies to
      // the matching.
      this.flags.not = false;
    }

    var name = this.obj.name || 'fn';
    this.assert(
        thrown
      , function(){ return 'expected ' + name + ' to throw an exception' }
      , function(){ return 'expected ' + name + ' not to throw an exception' });
  };

  /**
   * Checks if the array is empty.
   *
   * @api public
   */

  Assertion.prototype.empty = function () {
    var expectation;

    if ('object' == typeof this.obj && null !== this.obj && !isArray(this.obj)) {
      if ('number' == typeof this.obj.length) {
        expectation = !this.obj.length;
      } else {
        expectation = !keys(this.obj).length;
      }
    } else {
      if ('string' != typeof this.obj) {
        expect(this.obj).to.be.an('object');
      }

      expect(this.obj).to.have.property('length');
      expectation = !this.obj.length;
    }

    this.assert(
        expectation
      , function(){ return 'expected ' + i(this.obj) + ' to be empty' }
      , function(){ return 'expected ' + i(this.obj) + ' to not be empty' });
    return this;
  };

  /**
   * Checks if the obj exactly equals another.
   *
   * @api public
   */

  Assertion.prototype.be =
  Assertion.prototype.equal = function (obj) {
    this.assert(
        obj === this.obj
      , function(){ return 'expected ' + i(this.obj) + ' to equal ' + i(obj) }
      , function(){ return 'expected ' + i(this.obj) + ' to not equal ' + i(obj) });
    return this;
  };

  /**
   * Checks if the obj sortof equals another.
   *
   * @api public
   */

  Assertion.prototype.eql = function (obj) {
    this.assert(
        expect.eql(obj, this.obj)
      , function(){ return 'expected ' + i(this.obj) + ' to sort of equal ' + i(obj) }
      , function(){ return 'expected ' + i(this.obj) + ' to sort of not equal ' + i(obj) });
    return this;
  };

  /**
   * Assert within start to finish (inclusive).
   *
   * @param {Number} start
   * @param {Number} finish
   * @api public
   */

  Assertion.prototype.within = function (start, finish) {
    var range = start + '..' + finish;
    this.assert(
        this.obj >= start && this.obj <= finish
      , function(){ return 'expected ' + i(this.obj) + ' to be within ' + range }
      , function(){ return 'expected ' + i(this.obj) + ' to not be within ' + range });
    return this;
  };

  /**
   * Assert typeof / instance of
   *
   * @api public
   */

  Assertion.prototype.a =
  Assertion.prototype.an = function (type) {
    if ('string' == typeof type) {
      // proper english in error msg
      var n = /^[aeiou]/.test(type) ? 'n' : '';

      // typeof with support for 'array'
      this.assert(
          'array' == type ? isArray(this.obj) :
            'object' == type
              ? 'object' == typeof this.obj && null !== this.obj
              : type == typeof this.obj
        , function(){ return 'expected ' + i(this.obj) + ' to be a' + n + ' ' + type }
        , function(){ return 'expected ' + i(this.obj) + ' not to be a' + n + ' ' + type });
    } else {
      // instanceof
      var name = type.name || 'supplied constructor';
      this.assert(
          this.obj instanceof type
        , function(){ return 'expected ' + i(this.obj) + ' to be an instance of ' + name }
        , function(){ return 'expected ' + i(this.obj) + ' not to be an instance of ' + name });
    }

    return this;
  };

  /**
   * Assert numeric value above _n_.
   *
   * @param {Number} n
   * @api public
   */

  Assertion.prototype.greaterThan =
  Assertion.prototype.above = function (n) {
    this.assert(
        this.obj > n
      , function(){ return 'expected ' + i(this.obj) + ' to be above ' + n }
      , function(){ return 'expected ' + i(this.obj) + ' to be below ' + n });
    return this;
  };

  /**
   * Assert numeric value below _n_.
   *
   * @param {Number} n
   * @api public
   */

  Assertion.prototype.lessThan =
  Assertion.prototype.below = function (n) {
    this.assert(
        this.obj < n
      , function(){ return 'expected ' + i(this.obj) + ' to be below ' + n }
      , function(){ return 'expected ' + i(this.obj) + ' to be above ' + n });
    return this;
  };

  /**
   * Assert string value matches _regexp_.
   *
   * @param {RegExp} regexp
   * @api public
   */

  Assertion.prototype.match = function (regexp) {
    this.assert(
        regexp.exec(this.obj)
      , function(){ return 'expected ' + i(this.obj) + ' to match ' + regexp }
      , function(){ return 'expected ' + i(this.obj) + ' not to match ' + regexp });
    return this;
  };

  /**
   * Assert property "length" exists and has value of _n_.
   *
   * @param {Number} n
   * @api public
   */

  Assertion.prototype.length = function (n) {
    expect(this.obj).to.have.property('length');
    var len = this.obj.length;
    this.assert(
        n == len
      , function(){ return 'expected ' + i(this.obj) + ' to have a length of ' + n + ' but got ' + len }
      , function(){ return 'expected ' + i(this.obj) + ' to not have a length of ' + len });
    return this;
  };

  /**
   * Assert property _name_ exists, with optional _val_.
   *
   * @param {String} name
   * @param {Mixed} val
   * @api public
   */

  Assertion.prototype.property = function (name, val) {
    if (this.flags.own) {
      this.assert(
          Object.prototype.hasOwnProperty.call(this.obj, name)
        , function(){ return 'expected ' + i(this.obj) + ' to have own property ' + i(name) }
        , function(){ return 'expected ' + i(this.obj) + ' to not have own property ' + i(name) });
      return this;
    }

    if (this.flags.not && undefined !== val) {
      if (undefined === this.obj[name]) {
        throw new Error(i(this.obj) + ' has no property ' + i(name));
      }
    } else {
      var hasProp;
      try {
        hasProp = name in this.obj
      } catch (e) {
        hasProp = undefined !== this.obj[name]
      }

      this.assert(
          hasProp
        , function(){ return 'expected ' + i(this.obj) + ' to have a property ' + i(name) }
        , function(){ return 'expected ' + i(this.obj) + ' to not have a property ' + i(name) });
    }

    if (undefined !== val) {
      this.assert(
          val === this.obj[name]
        , function(){ return 'expected ' + i(this.obj) + ' to have a property ' + i(name)
          + ' of ' + i(val) + ', but got ' + i(this.obj[name]) }
        , function(){ return 'expected ' + i(this.obj) + ' to not have a property ' + i(name)
          + ' of ' + i(val) });
    }

    this.obj = this.obj[name];
    return this;
  };

  /**
   * Assert that the array contains _obj_ or string contains _obj_.
   *
   * @param {Mixed} obj|string
   * @api public
   */

  Assertion.prototype.string =
  Assertion.prototype.contain = function (obj) {
    if ('string' == typeof this.obj) {
      this.assert(
          ~this.obj.indexOf(obj)
        , function(){ return 'expected ' + i(this.obj) + ' to contain ' + i(obj) }
        , function(){ return 'expected ' + i(this.obj) + ' to not contain ' + i(obj) });
    } else {
      this.assert(
          ~indexOf(this.obj, obj)
        , function(){ return 'expected ' + i(this.obj) + ' to contain ' + i(obj) }
        , function(){ return 'expected ' + i(this.obj) + ' to not contain ' + i(obj) });
    }
    return this;
  };

  /**
   * Assert exact keys or inclusion of keys by using
   * the `.own` modifier.
   *
   * @param {Array|String ...} keys
   * @api public
   */

  Assertion.prototype.key =
  Assertion.prototype.keys = function ($keys) {
    var str
      , ok = true;

    $keys = isArray($keys)
      ? $keys
      : Array.prototype.slice.call(arguments);

    if (!$keys.length) throw new Error('keys required');

    var actual = keys(this.obj)
      , len = $keys.length;

    // Inclusion
    ok = every($keys, function (key) {
      return ~indexOf(actual, key);
    });

    // Strict
    if (!this.flags.not && this.flags.only) {
      ok = ok && $keys.length == actual.length;
    }

    // Key string
    if (len > 1) {
      $keys = map($keys, function (key) {
        return i(key);
      });
      var last = $keys.pop();
      str = $keys.join(', ') + ', and ' + last;
    } else {
      str = i($keys[0]);
    }

    // Form
    str = (len > 1 ? 'keys ' : 'key ') + str;

    // Have / include
    str = (!this.flags.only ? 'include ' : 'only have ') + str;

    // Assertion
    this.assert(
        ok
      , function(){ return 'expected ' + i(this.obj) + ' to ' + str }
      , function(){ return 'expected ' + i(this.obj) + ' to not ' + str });

    return this;
  };
  /**
   * Assert a failure.
   *
   * @param {String ...} custom message
   * @api public
   */
  Assertion.prototype.fail = function (msg) {
    msg = msg || "explicit failure";
    this.assert(false, msg, msg);
    return this;
  };

  /**
   * Function bind implementation.
   */

  function bind (fn, scope) {
    return function () {
      return fn.apply(scope, arguments);
    }
  }

  /**
   * Array every compatibility
   *
   * @see bit.ly/5Fq1N2
   * @api public
   */

  function every (arr, fn, thisObj) {
    var scope = thisObj || global;
    for (var i = 0, j = arr.length; i < j; ++i) {
      if (!fn.call(scope, arr[i], i, arr)) {
        return false;
      }
    }
    return true;
  };

  /**
   * Array indexOf compatibility.
   *
   * @see bit.ly/a5Dxa2
   * @api public
   */

  function indexOf (arr, o, i) {
    if (Array.prototype.indexOf) {
      return Array.prototype.indexOf.call(arr, o, i);
    }

    if (arr.length === undefined) {
      return -1;
    }

    for (var j = arr.length, i = i < 0 ? i + j < 0 ? 0 : i + j : i || 0
        ; i < j && arr[i] !== o; i++);

    return j <= i ? -1 : i;
  };

  // https://gist.github.com/1044128/
  var getOuterHTML = function(element) {
    if ('outerHTML' in element) return element.outerHTML;
    var ns = "http://www.w3.org/1999/xhtml";
    var container = document.createElementNS(ns, '_');
    var elemProto = (window.HTMLElement || window.Element).prototype;
    var xmlSerializer = new XMLSerializer();
    var html;
    if (document.xmlVersion) {
      return xmlSerializer.serializeToString(element);
    } else {
      container.appendChild(element.cloneNode(false));
      html = container.innerHTML.replace('><', '>' + element.innerHTML + '<');
      container.innerHTML = '';
      return html;
    }
  };

  // Returns true if object is a DOM element.
  var isDOMElement = function (object) {
    if (typeof HTMLElement === 'object') {
      return object instanceof HTMLElement;
    } else {
      return object &&
        typeof object === 'object' &&
        object.nodeType === 1 &&
        typeof object.nodeName === 'string';
    }
  };

  /**
   * Inspects an object.
   *
   * @see taken from node.js `util` module (copyright Joyent, MIT license)
   * @api private
   */

  function i (obj, showHidden, depth) {
    var seen = [];

    function stylize (str) {
      return str;
    };

    function format (value, recurseTimes) {
      // Provide a hook for user-specified inspect functions.
      // Check that value is an object with an inspect function on it
      if (value && typeof value.inspect === 'function' &&
          // Filter out the util module, it's inspect function is special
          value !== exports &&
          // Also filter out any prototype objects using the circular check.
          !(value.constructor && value.constructor.prototype === value)) {
        return value.inspect(recurseTimes);
      }

      // Primitive types cannot have properties
      switch (typeof value) {
        case 'undefined':
          return stylize('undefined', 'undefined');

        case 'string':
          var simple = '\'' + json.stringify(value).replace(/^"|"$/g, '')
                                                   .replace(/'/g, "\\'")
                                                   .replace(/\\"/g, '"') + '\'';
          return stylize(simple, 'string');

        case 'number':
          return stylize('' + value, 'number');

        case 'boolean':
          return stylize('' + value, 'boolean');
      }
      // For some reason typeof null is "object", so special case here.
      if (value === null) {
        return stylize('null', 'null');
      }

      if (isDOMElement(value)) {
        return getOuterHTML(value);
      }

      // Look up the keys of the object.
      var visible_keys = keys(value);
      var $keys = showHidden ? Object.getOwnPropertyNames(value) : visible_keys;

      // Functions without properties can be shortcutted.
      if (typeof value === 'function' && $keys.length === 0) {
        if (isRegExp(value)) {
          return stylize('' + value, 'regexp');
        } else {
          var name = value.name ? ': ' + value.name : '';
          return stylize('[Function' + name + ']', 'special');
        }
      }

      // Dates without properties can be shortcutted
      if (isDate(value) && $keys.length === 0) {
        return stylize(value.toUTCString(), 'date');
      }

      var base, type, braces;
      // Determine the object type
      if (isArray(value)) {
        type = 'Array';
        braces = ['[', ']'];
      } else {
        type = 'Object';
        braces = ['{', '}'];
      }

      // Make functions say that they are functions
      if (typeof value === 'function') {
        var n = value.name ? ': ' + value.name : '';
        base = (isRegExp(value)) ? ' ' + value : ' [Function' + n + ']';
      } else {
        base = '';
      }

      // Make dates with properties first say the date
      if (isDate(value)) {
        base = ' ' + value.toUTCString();
      }

      if ($keys.length === 0) {
        return braces[0] + base + braces[1];
      }

      if (recurseTimes < 0) {
        if (isRegExp(value)) {
          return stylize('' + value, 'regexp');
        } else {
          return stylize('[Object]', 'special');
        }
      }

      seen.push(value);

      var output = map($keys, function (key) {
        var name, str;
        if (value.__lookupGetter__) {
          if (value.__lookupGetter__(key)) {
            if (value.__lookupSetter__(key)) {
              str = stylize('[Getter/Setter]', 'special');
            } else {
              str = stylize('[Getter]', 'special');
            }
          } else {
            if (value.__lookupSetter__(key)) {
              str = stylize('[Setter]', 'special');
            }
          }
        }
        if (indexOf(visible_keys, key) < 0) {
          name = '[' + key + ']';
        }
        if (!str) {
          if (indexOf(seen, value[key]) < 0) {
            if (recurseTimes === null) {
              str = format(value[key]);
            } else {
              str = format(value[key], recurseTimes - 1);
            }
            if (str.indexOf('\n') > -1) {
              if (isArray(value)) {
                str = map(str.split('\n'), function (line) {
                  return '  ' + line;
                }).join('\n').substr(2);
              } else {
                str = '\n' + map(str.split('\n'), function (line) {
                  return '   ' + line;
                }).join('\n');
              }
            }
          } else {
            str = stylize('[Circular]', 'special');
          }
        }
        if (typeof name === 'undefined') {
          if (type === 'Array' && key.match(/^\d+$/)) {
            return str;
          }
          name = json.stringify('' + key);
          if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
            name = name.substr(1, name.length - 2);
            name = stylize(name, 'name');
          } else {
            name = name.replace(/'/g, "\\'")
                       .replace(/\\"/g, '"')
                       .replace(/(^"|"$)/g, "'");
            name = stylize(name, 'string');
          }
        }

        return name + ': ' + str;
      });

      seen.pop();

      var numLinesEst = 0;
      var length = reduce(output, function (prev, cur) {
        numLinesEst++;
        if (indexOf(cur, '\n') >= 0) numLinesEst++;
        return prev + cur.length + 1;
      }, 0);

      if (length > 50) {
        output = braces[0] +
                 (base === '' ? '' : base + '\n ') +
                 ' ' +
                 output.join(',\n  ') +
                 ' ' +
                 braces[1];

      } else {
        output = braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
      }

      return output;
    }
    return format(obj, (typeof depth === 'undefined' ? 2 : depth));
  };

  function isArray (ar) {
    return Object.prototype.toString.call(ar) == '[object Array]';
  };

  function isRegExp(re) {
    var s;
    try {
      s = '' + re;
    } catch (e) {
      return false;
    }

    return re instanceof RegExp || // easy case
           // duck-type for context-switching evalcx case
           typeof(re) === 'function' &&
           re.constructor.name === 'RegExp' &&
           re.compile &&
           re.test &&
           re.exec &&
           s.match(/^\/.*\/[gim]{0,3}$/);
  };

  function isDate(d) {
    if (d instanceof Date) return true;
    return false;
  };

  function keys (obj) {
    if (Object.keys) {
      return Object.keys(obj);
    }

    var keys = [];

    for (var i in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, i)) {
        keys.push(i);
      }
    }

    return keys;
  }

  function map (arr, mapper, that) {
    if (Array.prototype.map) {
      return Array.prototype.map.call(arr, mapper, that);
    }

    var other= new Array(arr.length);

    for (var i= 0, n = arr.length; i<n; i++)
      if (i in arr)
        other[i] = mapper.call(that, arr[i], i, arr);

    return other;
  };

  function reduce (arr, fun) {
    if (Array.prototype.reduce) {
      return Array.prototype.reduce.apply(
          arr
        , Array.prototype.slice.call(arguments, 1)
      );
    }

    var len = +this.length;

    if (typeof fun !== "function")
      throw new TypeError();

    // no value to return if no initial value and an empty array
    if (len === 0 && arguments.length === 1)
      throw new TypeError();

    var i = 0;
    if (arguments.length >= 2) {
      var rv = arguments[1];
    } else {
      do {
        if (i in this) {
          rv = this[i++];
          break;
        }

        // if array contains no values, no initial value to return
        if (++i >= len)
          throw new TypeError();
      } while (true);
    }

    for (; i < len; i++) {
      if (i in this)
        rv = fun.call(null, rv, this[i], i, this);
    }

    return rv;
  };

  /**
   * Asserts deep equality
   *
   * @see taken from node.js `assert` module (copyright Joyent, MIT license)
   * @api private
   */

  expect.eql = function eql (actual, expected) {
    // 7.1. All identical values are equivalent, as determined by ===.
    if (actual === expected) {
      return true;
    } else if ('undefined' != typeof Buffer
        && Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
      if (actual.length != expected.length) return false;

      for (var i = 0; i < actual.length; i++) {
        if (actual[i] !== expected[i]) return false;
      }

      return true;

    // 7.2. If the expected value is a Date object, the actual value is
    // equivalent if it is also a Date object that refers to the same time.
    } else if (actual instanceof Date && expected instanceof Date) {
      return actual.getTime() === expected.getTime();

    // 7.3. Other pairs that do not both pass typeof value == "object",
    // equivalence is determined by ==.
    } else if (typeof actual != 'object' && typeof expected != 'object') {
      return actual == expected;

    // 7.4. For all other Object pairs, including Array objects, equivalence is
    // determined by having the same number of owned properties (as verified
    // with Object.prototype.hasOwnProperty.call), the same set of keys
    // (although not necessarily the same order), equivalent values for every
    // corresponding key, and an identical "prototype" property. Note: this
    // accounts for both named and indexed properties on Arrays.
    } else {
      return objEquiv(actual, expected);
    }
  }

  function isUndefinedOrNull (value) {
    return value === null || value === undefined;
  }

  function isArguments (object) {
    return Object.prototype.toString.call(object) == '[object Arguments]';
  }

  function objEquiv (a, b) {
    if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
      return false;
    // an identical "prototype" property.
    if (a.prototype !== b.prototype) return false;
    //~~~I've managed to break Object.keys through screwy arguments passing.
    //   Converting to array solves the problem.
    if (isArguments(a)) {
      if (!isArguments(b)) {
        return false;
      }
      a = pSlice.call(a);
      b = pSlice.call(b);
      return expect.eql(a, b);
    }
    try{
      var ka = keys(a),
        kb = keys(b),
        key, i;
    } catch (e) {//happens when one is a string literal and the other isn't
      return false;
    }
    // having the same number of owned properties (keys incorporates hasOwnProperty)
    if (ka.length != kb.length)
      return false;
    //the same set of keys (although not necessarily the same order),
    ka.sort();
    kb.sort();
    //~~~cheap key test
    for (i = ka.length - 1; i >= 0; i--) {
      if (ka[i] != kb[i])
        return false;
    }
    //equivalent values for every corresponding key, and
    //~~~possibly expensive deep test
    for (i = ka.length - 1; i >= 0; i--) {
      key = ka[i];
      if (!expect.eql(a[key], b[key]))
         return false;
    }
    return true;
  }

  var json = (function () {
    "use strict";

    if ('object' == typeof JSON && JSON.parse && JSON.stringify) {
      return {
          parse: nativeJSON.parse
        , stringify: nativeJSON.stringify
      }
    }

    var JSON = {};

    function f(n) {
        // Format integers to have at least two digits.
        return n < 10 ? '0' + n : n;
    }

    function date(d, key) {
      return isFinite(d.valueOf()) ?
          d.getUTCFullYear()     + '-' +
          f(d.getUTCMonth() + 1) + '-' +
          f(d.getUTCDate())      + 'T' +
          f(d.getUTCHours())     + ':' +
          f(d.getUTCMinutes())   + ':' +
          f(d.getUTCSeconds())   + 'Z' : null;
    };

    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
        escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
        gap,
        indent,
        meta = {    // table of character substitutions
            '\b': '\\b',
            '\t': '\\t',
            '\n': '\\n',
            '\f': '\\f',
            '\r': '\\r',
            '"' : '\\"',
            '\\': '\\\\'
        },
        rep;


    function quote(string) {

  // If the string contains no control characters, no quote characters, and no
  // backslash characters, then we can safely slap some quotes around it.
  // Otherwise we must also replace the offending characters with safe escape
  // sequences.

        escapable.lastIndex = 0;
        return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
            var c = meta[a];
            return typeof c === 'string' ? c :
                '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
        }) + '"' : '"' + string + '"';
    }


    function str(key, holder) {

  // Produce a string from holder[key].

        var i,          // The loop counter.
            k,          // The member key.
            v,          // The member value.
            length,
            mind = gap,
            partial,
            value = holder[key];

  // If the value has a toJSON method, call it to obtain a replacement value.

        if (value instanceof Date) {
            value = date(key);
        }

  // If we were called with a replacer function, then call the replacer to
  // obtain a replacement value.

        if (typeof rep === 'function') {
            value = rep.call(holder, key, value);
        }

  // What happens next depends on the value's type.

        switch (typeof value) {
        case 'string':
            return quote(value);

        case 'number':

  // JSON numbers must be finite. Encode non-finite numbers as null.

            return isFinite(value) ? String(value) : 'null';

        case 'boolean':
        case 'null':

  // If the value is a boolean or null, convert it to a string. Note:
  // typeof null does not produce 'null'. The case is included here in
  // the remote chance that this gets fixed someday.

            return String(value);

  // If the type is 'object', we might be dealing with an object or an array or
  // null.

        case 'object':

  // Due to a specification blunder in ECMAScript, typeof null is 'object',
  // so watch out for that case.

            if (!value) {
                return 'null';
            }

  // Make an array to hold the partial results of stringifying this object value.

            gap += indent;
            partial = [];

  // Is the value an array?

            if (Object.prototype.toString.apply(value) === '[object Array]') {

  // The value is an array. Stringify every element. Use null as a placeholder
  // for non-JSON values.

                length = value.length;
                for (i = 0; i < length; i += 1) {
                    partial[i] = str(i, value) || 'null';
                }

  // Join all of the elements together, separated with commas, and wrap them in
  // brackets.

                v = partial.length === 0 ? '[]' : gap ?
                    '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' :
                    '[' + partial.join(',') + ']';
                gap = mind;
                return v;
            }

  // If the replacer is an array, use it to select the members to be stringified.

            if (rep && typeof rep === 'object') {
                length = rep.length;
                for (i = 0; i < length; i += 1) {
                    if (typeof rep[i] === 'string') {
                        k = rep[i];
                        v = str(k, value);
                        if (v) {
                            partial.push(quote(k) + (gap ? ': ' : ':') + v);
                        }
                    }
                }
            } else {

  // Otherwise, iterate through all of the keys in the object.

                for (k in value) {
                    if (Object.prototype.hasOwnProperty.call(value, k)) {
                        v = str(k, value);
                        if (v) {
                            partial.push(quote(k) + (gap ? ': ' : ':') + v);
                        }
                    }
                }
            }

  // Join all of the member texts together, separated with commas,
  // and wrap them in braces.

            v = partial.length === 0 ? '{}' : gap ?
                '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
                '{' + partial.join(',') + '}';
            gap = mind;
            return v;
        }
    }

  // If the JSON object does not yet have a stringify method, give it one.

    JSON.stringify = function (value, replacer, space) {

  // The stringify method takes a value and an optional replacer, and an optional
  // space parameter, and returns a JSON text. The replacer can be a function
  // that can replace values, or an array of strings that will select the keys.
  // A default replacer method can be provided. Use of the space parameter can
  // produce text that is more easily readable.

        var i;
        gap = '';
        indent = '';

  // If the space parameter is a number, make an indent string containing that
  // many spaces.

        if (typeof space === 'number') {
            for (i = 0; i < space; i += 1) {
                indent += ' ';
            }

  // If the space parameter is a string, it will be used as the indent string.

        } else if (typeof space === 'string') {
            indent = space;
        }

  // If there is a replacer, it must be a function or an array.
  // Otherwise, throw an error.

        rep = replacer;
        if (replacer && typeof replacer !== 'function' &&
                (typeof replacer !== 'object' ||
                typeof replacer.length !== 'number')) {
            throw new Error('JSON.stringify');
        }

  // Make a fake root object containing our value under the key of ''.
  // Return the result of stringifying the value.

        return str('', {'': value});
    };

  // If the JSON object does not yet have a parse method, give it one.

    JSON.parse = function (text, reviver) {
    // The parse method takes a text and an optional reviver function, and returns
    // a JavaScript value if the text is a valid JSON text.

        var j;

        function walk(holder, key) {

    // The walk method is used to recursively walk the resulting structure so
    // that modifications can be made.

            var k, v, value = holder[key];
            if (value && typeof value === 'object') {
                for (k in value) {
                    if (Object.prototype.hasOwnProperty.call(value, k)) {
                        v = walk(value, k);
                        if (v !== undefined) {
                            value[k] = v;
                        } else {
                            delete value[k];
                        }
                    }
                }
            }
            return reviver.call(holder, key, value);
        }


    // Parsing happens in four stages. In the first stage, we replace certain
    // Unicode characters with escape sequences. JavaScript handles many characters
    // incorrectly, either silently deleting them, or treating them as line endings.

        text = String(text);
        cx.lastIndex = 0;
        if (cx.test(text)) {
            text = text.replace(cx, function (a) {
                return '\\u' +
                    ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
            });
        }

    // In the second stage, we run the text against regular expressions that look
    // for non-JSON patterns. We are especially concerned with '()' and 'new'
    // because they can cause invocation, and '=' because it can cause mutation.
    // But just to be safe, we want to reject all unexpected forms.

    // We split the second stage into 4 regexp operations in order to work around
    // crippling inefficiencies in IE's and Safari's regexp engines. First we
    // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
    // replace all simple value tokens with ']' characters. Third, we delete all
    // open brackets that follow a colon or comma or that begin the text. Finally,
    // we look to see that the remaining characters are only whitespace or ']' or
    // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.

        if (/^[\],:{}\s]*$/
                .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
                    .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
                    .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {

    // In the third stage we use the eval function to compile the text into a
    // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
    // in JavaScript: it can begin a block or an object literal. We wrap the text
    // in parens to eliminate the ambiguity.

            j = eval('(' + text + ')');

    // In the optional fourth stage, we recursively walk the new structure, passing
    // each name/value pair to a reviver function for possible transformation.

            return typeof reviver === 'function' ?
                walk({'': j}, '') : j;
        }

    // If the text is not JSON parseable, then a SyntaxError is thrown.

        throw new SyntaxError('JSON.parse');
    };

    return JSON;
  })();

  if ('undefined' != typeof window) {
    window.expect = module.exports;
  }

})(
    this
  , 'undefined' != typeof module ? module : {}
  , 'undefined' != typeof exports ? exports : {}
);


================================================
FILE: vendors/firmcard/test/mocha.css
================================================
@charset "utf-8";

body {
  font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif;
  padding: 60px 50px;
}

#mocha ul, #mocha li {
  margin: 0;
  padding: 0;
}

#mocha ul {
  list-style: none;
}

#mocha h1, #mocha h2 {
  margin: 0;
}

#mocha h1 {
  margin-top: 15px;
  font-size: 1em;
  font-weight: 200;
}

#mocha h1 a {
  text-decoration: none;
  color: inherit;
}

#mocha h1 a:hover {
  text-decoration: underline;
}

#mocha .suite .suite h1 {
  margin-top: 0;
  font-size: .8em;
}

.hidden {
  display: none;
}

#mocha h2 {
  font-size: 12px;
  font-weight: normal;
  cursor: pointer;
}

#mocha .suite {
  margin-left: 15px;
}

#mocha .test {
  margin-left: 15px;
  overflow: hidden;
}

#mocha .test.pending:hover h2::after {
  content: '(pending)';
  font-family: arial;
}

#mocha .test.pass.medium .duration {
  background: #C09853;
}

#mocha .test.pass.slow .duration {
  background: #B94A48;
}

#mocha .test.pass::before {
  content: '✓';
  font-size: 12px;
  display: block;
  float: left;
  margin-right: 5px;
  color: #00d6b2;
}

#mocha .test.pass .duration {
  font-size: 9px;
  margin-left: 5px;
  padding: 2px 5px;
  color: white;
  -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
  -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
  box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
  -webkit-border-radius: 5px;
  -moz-border-radius: 5px;
  -ms-border-radius: 5px;
  -o-border-radius: 5px;
  border-radius: 5px;
}

#mocha .test.pass.fast .duration {
  display: none;
}

#mocha .test.pending {
  color: #0b97c4;
}

#mocha .test.pending::before {
  content: '◦';
  color: #0b97c4;
}

#mocha .test.fail {
  color: #c00;
}

#mocha .test.fail pre {
  color: black;
}

#mocha .test.fail::before {
  content: '✖';
  font-size: 12px;
  display: block;
  float: left;
  margin-right: 5px;
  color: #c00;
}

#mocha .test pre.error {
  color: #c00;
  max-height: 300px;
  overflow: auto;
}

#mocha .test pre {
  display: block;
  float: left;
  clear: left;
  font: 12px/1.5 monaco, monospace;
  margin: 5px;
  padding: 15px;
  border: 1px solid #eee;
  border-bottom-color: #ddd;
  -webkit-border-radius: 3px;
  -webkit-box-shadow: 0 1px 3px #eee;
  -moz-border-radius: 3px;
  -moz-box-shadow: 0 1px 3px #eee;
}

#mocha .test h2 {
  position: relative;
}

#mocha .test a.replay {
  position: absolute;
  top: 3px;
  right: 0;
  text-decoration: none;
  vertical-align: middle;
  display: block;
  width: 15px;
  height: 15px;
  line-height: 15px;
  text-align: center;
  background: #eee;
  font-size: 15px;
  -moz-border-radius: 15px;
  border-radius: 15px;
  -webkit-transition: opacity 200ms;
  -moz-transition: opacity 200ms;
  transition: opacity 200ms;
  opacity: 0.3;
  color: #888;
}

#mocha .test:hover a.replay {
  opacity: 1;
}

#mocha-report.pass .test.fail {
  display: none;
}

#mocha-report.fail .test.pass {
  display: none;
}

#mocha-error {
  color: #c00;
  font-size: 1.5  em;
  font-weight: 100;
  letter-spacing: 1px;
}

#mocha-stats {
  position: fixed;
  top: 15px;
  right: 10px;
  font-size: 12px;
  margin: 0;
  color: #888;
}

#mocha-stats .progress {
  float: right;
  padding-top: 0;
}

#mocha-stats em {
  color: black;
}

#mocha-stats a {
  text-decoration: none;
  color: inherit;
}

#mocha-stats a:hover {
  border-bottom: 1px solid #eee;
}

#mocha-stats li {
  display: inline-block;
  margin: 0 5px;
  list-style: none;
  padding-top: 11px;
}

#mocha-stats canvas {
  width: 40px;
  height: 40px;
}

code .comment { color: #ddd }
code .init { color: #2F6FAD }
code .string { color: #5890AD }
code .keyword { color: #8A6343 }
code .number { color: #2F6FAD }

@media screen and (max-device-width: 480px) {
  body {
    padding: 60px 0px;
  }

  #stats {
    position: absolute;
  }
}

================================================
FILE: vendors/firmcard/test/mocha.js
================================================
;(function(){

// CommonJS require()

function require(p){
    var path = require.resolve(p)
      , mod = require.modules[path];
    if (!mod) throw new Error('failed to require "' + p + '"');
    if (!mod.exports) {
      mod.exports = {};
      mod.call(mod.exports, mod, mod.exports, require.relative(path));
    }
    return mod.exports;
  }

require.modules = {};

require.resolve = function (path){
    var orig = path
      , reg = path + '.js'
      , index = path + '/index.js';
    return require.modules[reg] && reg
      || require.modules[index] && index
      || orig;
  };

require.register = function (path, fn){
    require.modules[path] = fn;
  };

require.relative = function (parent) {
    return function(p){
      if ('.' != p.charAt(0)) return require(p);

      var path = parent.split('/')
        , segs = p.split('/');
      path.pop();

      for (var i = 0; i < segs.length; i++) {
        var seg = segs[i];
        if ('..' == seg) path.pop();
        else if ('.' != seg) path.push(seg);
      }

      return require(path.join('/'));
    };
  };


require.register("browser/debug.js", function(module, exports, require){

module.exports = function(type){
  return function(){
  }
};

}); // module: browser/debug.js

require.register("browser/diff.js", function(module, exports, require){
/* See license.txt for terms of usage */

/*
 * Text diff implementation.
 * 
 * This library supports the following APIS:
 * JsDiff.diffChars: Character by character diff
 * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace
 * JsDiff.diffLines: Line based diff
 * 
 * JsDiff.diffCss: Diff targeted at CSS content
 * 
 * These methods are based on the implementation proposed in
 * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986).
 * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927
 */
var JsDiff = (function() {
  function clonePath(path) {
    return { newPos: path.newPos, components: path.components.slice(0) };
  }
  function removeEmpty(array) {
    var ret = [];
    for (var i = 0; i < array.length; i++) {
      if (array[i]) {
        ret.push(array[i]);
      }
    }
    return ret;
  }
  function escapeHTML(s) {
    var n = s;
    n = n.replace(/&/g, "&amp;");
    n = n.replace(/</g, "&lt;");
    n = n.replace(/>/g, "&gt;");
    n = n.replace(/"/g, "&quot;");

    return n;
  }


  var fbDiff = function(ignoreWhitespace) {
    this.ignoreWhitespace = ignoreWhitespace;
  };
  fbDiff.prototype = {
      diff: function(oldString, newString) {
        // Handle the identity case (this is due to unrolling editLength == 0
        if (newString == oldString) {
          return [{ value: newString }];
        }
        if (!newString) {
          return [{ value: oldString, removed: true }];
        }
        if (!oldString) {
          return [{ value: newString, added: true }];
        }

        newString = this.tokenize(newString);
        oldString = this.tokenize(oldString);

        var newLen = newString.length, oldLen = oldString.length;
        var maxEditLength = newLen + oldLen;
        var bestPath = [{ newPos: -1, components: [] }];

        // Seed editLength = 0
        var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
        if (bestPath[0].newPos+1 >= newLen && oldPos+1 >= oldLen) {
          return bestPath[0].components;
        }

        for (var editLength = 1; editLength <= maxEditLength; editLength++) {
          for (var diagonalPath = -1*editLength; diagonalPath <= editLength; diagonalPath+=2) {
            var basePath;
            var addPath = bestPath[diagonalPath-1],
                removePath = bestPath[diagonalPath+1];
            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
            if (addPath) {
              // No one else is going to attempt to use this value, clear it
              bestPath[diagonalPath-1] = undefined;
            }

            var canAdd = addPath && addPath.newPos+1 < newLen;
            var canRemove = removePath && 0 <= oldPos && oldPos < oldLen;
            if (!canAdd && !canRemove) {
              bestPath[diagonalPath] = undefined;
              continue;
            }

            // Select the diagonal that we want to branch from. We select the prior
            // path whose position in the new string is the farthest from the origin
            // and does not pass the bounds of the diff graph
            if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {
              basePath = clonePath(removePath);
              this.pushComponent(basePath.components, oldString[oldPos], undefined, true);
            } else {
              basePath = clonePath(addPath);
              basePath.newPos++;
              this.pushComponent(basePath.components, newString[basePath.newPos], true, undefined);
            }

            var oldPos = this.extractCommon(basePath, newString, oldString, diagonalPath);

            if (basePath.newPos+1 >= newLen && oldPos+1 >= oldLen) {
              return basePath.components;
            } else {
              bestPath[diagonalPath] = basePath;
            }
          }
        }
      },

      pushComponent: function(components, value, added, removed) {
        var last = components[components.length-1];
        if (last && last.added === added && last.removed === removed) {
          // We need to clone here as the component clone operation is just
          // as shallow array clone
          components[components.length-1] =
            {value: this.join(last.value, value), added: added, removed: removed };
        } else {
          components.push({value: value, added: added, removed: removed });
        }
      },
      extractCommon: function(basePath, newString, oldString, diagonalPath) {
        var newLen = newString.length,
            oldLen = oldString.length,
            newPos = basePath.newPos,
            oldPos = newPos - diagonalPath;
        while (newPos+1 < newLen && oldPos+1 < oldLen && this.equals(newString[newPos+1], oldString[oldPos+1])) {
          newPos++;
          oldPos++;
          
          this.pushComponent(basePath.components, newString[newPos], undefined, undefined);
        }
        basePath.newPos = newPos;
        return oldPos;
      },

      equals: function(left, right) {
        var reWhitespace = /\S/;
        if (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)) {
          return true;
        } else {
          return left == right;
        }
      },
      join: function(left, right) {
        return left + right;
      },
      tokenize: function(value) {
        return value;
      }
  };
  
  var CharDiff = new fbDiff();
  
  var WordDiff = new fbDiff(true);
  WordDiff.tokenize = function(value) {
    return removeEmpty(value.split(/(\s+|\b)/));
  };
  
  var CssDiff = new fbDiff(true);
  CssDiff.tokenize = function(value) {
    return removeEmpty(value.split(/([{}:;,]|\s+)/));
  };
  
  var LineDiff = new fbDiff();
  LineDiff.tokenize = function(value) {
    return value.split(/^/m);
  };
  
  return {
    diffChars: function(oldStr, newStr) { return CharDiff.diff(oldStr, newStr); },
    diffWords: function(oldStr, newStr) { return WordDiff.diff(oldStr, newStr); },
    diffLines: function(oldStr, newStr) { return LineDiff.diff(oldStr, newStr); },

    diffCss: function(oldStr, newStr) { return CssDiff.diff(oldStr, newStr); },

    createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) {
      var ret = [];

      ret.push("Index: " + fileName);
      ret.push("===================================================================");
      ret.push("--- " + fileName + (typeof oldHeader === "undefined" ? "" : "\t" + oldHeader));
      ret.push("+++ " + fileName + (typeof newHeader === "undefined" ? "" : "\t" + newHeader));

      var diff = LineDiff.diff(oldStr, newStr);
      if (!diff[diff.length-1].value) {
        diff.pop();   // Remove trailing newline add
      }
      diff.push({value: "", lines: []});   // Append an empty value to make cleanup easier

      function contextLines(lines) {
        return lines.map(function(entry) { return ' ' + entry; });
      }
      function eofNL(curRange, i, current) {
        var last = diff[diff.length-2],
            isLast = i === diff.length-2,
            isLastOfType = i === diff.length-3 && (current.added === !last.added || current.removed === !last.removed);

        // Figure out if this is the last line for the given file and missing NL
        if (!/\n$/.test(current.value) && (isLast || isLastOfType)) {
          curRange.push('\\ No newline at end of file');
        }
      }

      var oldRangeStart = 0, newRangeStart = 0, curRange = [],
          oldLine = 1, newLine = 1;
      for (var i = 0; i < diff.length; i++) {
        var current = diff[i],
            lines = current.lines || current.value.replace(/\n$/, "").split("\n");
        current.lines = lines;

        if (current.added || current.removed) {
          if (!oldRangeStart) {
            var prev = diff[i-1];
            oldRangeStart = oldLine;
            newRangeStart = newLine;
            
            if (prev) {
              curRange = contextLines(prev.lines.slice(-4));
              oldRangeStart -= curRange.length;
              newRangeStart -= curRange.length;
            }
          }
          curRange.push.apply(curRange, lines.map(function(entry) { return (current.added?"+":"-") + entry; }));
          eofNL(curRange, i, current);

          if (current.added) {
            newLine += lines.length;
          } else {
            oldLine += lines.length;
          }
        } else {
          if (oldRangeStart) {
            // Close out any changes that have been output (or join overlapping)
            if (lines.length <= 8 && i < diff.length-2) {
              // Overlapping
              curRange.push.apply(curRange, contextLines(lines));
            } else {
              // end the range and output
              var contextSize = Math.min(lines.length, 4);
              ret.push(
                  "@@ -" + oldRangeStart + "," + (oldLine-oldRangeStart+contextSize)
                  + " +" + newRangeStart + "," + (newLine-newRangeStart+contextSize)
                  + " @@");
              ret.push.apply(ret, curRange);
              ret.push.apply(ret, contextLines(lines.slice(0, contextSize)));
              if (lines.length <= 4) {
                eofNL(ret, i, current);
              }

              oldRangeStart = 0;  newRangeStart = 0; curRange = [];
            }
          }
          oldLine += lines.length;
          newLine += lines.length;
        }
      }

      return ret.join('\n') + '\n';
    },

    convertChangesToXML: function(changes){
      var ret = [];
      for ( var i = 0; i < changes.length; i++) {
        var change = changes[i];
        if (change.added) {
          ret.push("<ins>");
        } else if (change.removed) {
          ret.push("<del>");
        }

        ret.push(escapeHTML(change.value));

        if (change.added) {
          ret.push("</ins>");
        } else if (change.removed) {
          ret.push("</del>");
        }
      }
      return ret.join("");
    }
  };
})();

if (typeof module !== "undefined") {
    module.exports = JsDiff;
}

}); // module: browser/diff.js

require.register("browser/events.js", function(module, exports, require){

/**
 * Module exports.
 */

exports.EventEmitter = EventEmitter;

/**
 * Check if `obj` is an array.
 */

function isArray(obj) {
  return '[object Array]' == {}.toString.call(obj);
}

/**
 * Event emitter constructor.
 *
 * @api public
 */

function EventEmitter(){};

/**
 * Adds a listener.
 *
 * @api public
 */

EventEmitter.prototype.on = function (name, fn) {
  if (!this.$events) {
    this.$events = {};
  }

  if (!this.$events[name]) {
    this.$events[name] = fn;
  } else if (isArray(this.$events[name])) {
    this.$events[name].push(fn);
  } else {
    this.$events[name] = [this.$events[name], fn];
  }

  return this;
};

EventEmitter.prototype.addListener = EventEmitter.prototype.on;

/**
 * Adds a volatile listener.
 *
 * @api public
 */

EventEmitter.prototype.once = function (name, fn) {
  var self = this;

  function on () {
    self.removeListener(name, on);
    fn.apply(this, arguments);
  };

  on.listener = fn;
  this.on(name, on);

  return this;
};

/**
 * Removes a listener.
 *
 * @api public
 */

EventEmitter.prototype.removeListener = function (name, fn) {
  if (this.$events && this.$events[name]) {
    var list = this.$events[name];

    if (isArray(list)) {
      var pos = -1;

      for (var i = 0, l = list.length; i < l; i++) {
        if (list[i] === fn || (list[i].listener && list[i].listener === fn)) {
          pos = i;
          break;
        }
      }

      if (pos < 0) {
        return this;
      }

      list.splice(pos, 1);

      if (!list.length) {
        delete this.$events[name];
      }
    } else if (list === fn || (list.listener && list.listener === fn)) {
      delete this.$events[name];
    }
  }

  return this;
};

/**
 * Removes all listeners for an event.
 *
 * @api public
 */

EventEmitter.prototype.removeAllListeners = function (name) {
  if (name === undefined) {
    this.$events = {};
    return this;
  }

  if (this.$events && this.$events[name]) {
    this.$events[name] = null;
  }

  return this;
};

/**
 * Gets all listeners for a certain event.
 *
 * @api public
 */

EventEmitter.prototype.listeners = function (name) {
  if (!this.$events) {
    this.$events = {};
  }

  if (!this.$events[name]) {
    this.$events[name] = [];
  }

  if (!isArray(this.$events[name])) {
    this.$events[name] = [this.$events[name]];
  }

  return this.$events[name];
};

/**
 * Emits an event.
 *
 * @api public
 */

EventEmitter.prototype.emit = function (name) {
  if (!this.$events) {
    return false;
  }

  var handler = this.$events[name];

  if (!handler) {
    return false;
  }

  var args = [].slice.call(arguments, 1);

  if ('function' == typeof handler) {
    handler.apply(this, args);
  } else if (isArray(handler)) {
    var listeners = handler.slice();

    for (var i = 0, l = listeners.length; i < l; i++) {
      listeners[i].apply(this, args);
    }
  } else {
    return false;
  }

  return true;
};
}); // module: browser/events.js

require.register("browser/fs.js", function(module, exports, require){

}); // module: browser/fs.js

require.register("browser/path.js", function(module, exports, require){

}); // module: browser/path.js

require.register("browser/progress.js", function(module, exports, require){

/**
 * Expose `Progress`.
 */

module.exports = Progress;

/**
 * Initialize a new `Progress` indicator.
 */

function Progress() {
  this.percent = 0;
  this.size(0);
  this.fontSize(11);
  this.font('helvetica, arial, sans-serif');
}

/**
 * Set progress size to `n`.
 *
 * @param {Number} n
 * @return {Progress} for chaining
 * @api public
 */

Progress.prototype.size = function(n){
  this._size = n;
  return this;
};

/**
 * Set text to `str`.
 *
 * @param {String} str
 * @return {Progress} for chaining
 * @api public
 */

Progress.prototype.text = function(str){
  this._text = str;
  return this;
};

/**
 * Set font size to `n`.
 *
 * @param {Number} n
 * @return {Progress} for chaining
 * @api public
 */

Progress.prototype.fontSize = function(n){
  this._fontSize = n;
  return this;
};

/**
 * Set font `family`.
 *
 * @param {String} family
 * @return {Progress} for chaining
 */

Progress.prototype.font = function(family){
  this._font = family;
  return this;
};

/**
 * Update percentage to `n`.
 *
 * @param {Number} n
 * @return {Progress} for chaining
 */

Progress.prototype.update = function(n){
  this.percent = n;
  return this;
};

/**
 * Draw on `ctx`.
 *
 * @param {CanvasRenderingContext2d} ctx
 * @return {Progress} for chaining
 */

Progress.prototype.draw = function(ctx){
  var percent = Math.min(this.percent, 100)
    , size = this._size
    , half = size / 2
    , x = half
    , y = half
    , rad = half - 1
    , fontSize = this._fontSize;

  ctx.font = fontSize + 'px ' + this._font;

  var angle = Math.PI * 2 * (percent / 100);
  ctx.clearRect(0, 0, size, size);

  // outer circle
  ctx.strokeStyle = '#9f9f9f';
  ctx.beginPath();
  ctx.arc(x, y, rad, 0, angle, false);
  ctx.stroke();

  // inner circle
  ctx.strokeStyle = '#eee';
  ctx.beginPath();
  ctx.arc(x, y, rad - 1, 0, angle, true);
  ctx.stroke();

  // text
  var text = this._text || (percent | 0) + '%'
    , w = ctx.measureText(text).width;

  ctx.fillText(
      text
    , x - w / 2 + 1
    , y + fontSize / 2 - 1);

  return this;
};

}); // module: browser/progress.js

require.register("browser/tty.js", function(module, exports, require){

exports.isatty = function(){
  return true;
};

exports.getWindowSize = function(){
  return [window.innerHeight, window.innerWidth];
};
}); // module: browser/tty.js

require.register("context.js", function(module, exports, require){

/**
 * Expose `Context`.
 */

module.exports = Context;

/**
 * Initialize a new `Context`.
 *
 * @api private
 */

function Context(){}

/**
 * Set or get the context `Runnable` to `runnable`.
 *
 * @param {Runnable} runnable
 * @return {Context}
 * @api private
 */

Context.prototype.runnable = function(runnable){
  if (0 == arguments.length) return this._runnable;
  this.test = this._runnable = runnable;
  return this;
};

/**
 * Set test timeout `ms`.
 *
 * @param {Number} ms
 * @return {Context} self
 * @api private
 */

Context.prototype.timeout = function(ms){
  this.runnable().timeout(ms);
  return this;
};

/**
 * Set test slowness threshold `ms`.
 *
 * @param {Number} ms
 * @return {Context} self
 * @api private
 */

Context.prototype.slow = function(ms){
  this.runnable().slow(ms);
  return this;
};

/**
 * Inspect the context void of `._runnable`.
 *
 * @return {String}
 * @api private
 */

Context.prototype.inspect = function(){
  return JSON.stringify(this, function(key, val){
    if ('_runnable' == key) return;
    if ('test' == key) return;
    return val;
  }, 2);
};

}); // module: context.js

require.register("hook.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Runnable = require('./runnable');

/**
 * Expose `Hook`.
 */

module.exports = Hook;

/**
 * Initialize a new `Hook` with the given `title` and callback `fn`.
 *
 * @param {String} title
 * @param {Function} fn
 * @api private
 */

function Hook(title, fn) {
  Runnable.call(this, title, fn);
  this.type = 'hook';
}

/**
 * Inherit from `Runnable.prototype`.
 */

function F(){};
F.prototype = Runnable.prototype;
Hook.prototype = new F;
Hook.prototype.constructor = Hook;


/**
 * Get or set the test `err`.
 *
 * @param {Error} err
 * @return {Error}
 * @api public
 */

Hook.prototype.error = function(err){
  if (0 == arguments.length) {
    var err = this._error;
    this._error = null;
    return err;
  }

  this._error = err;
};

}); // module: hook.js

require.register("interfaces/bdd.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Suite = require('../suite')
  , Test = require('../test');

/**
 * BDD-style interface:
 *
 *      describe('Array', function(){
 *        describe('#indexOf()', function(){
 *          it('should return -1 when not present', function(){
 *
 *          });
 *
 *          it('should return the index when present', function(){
 *
 *          });
 *        });
 *      });
 *
 */

module.exports = function(suite){
  var suites = [suite];

  suite.on('pre-require', function(context, file, mocha){

    /**
     * Execute before running tests.
     */

    context.before = function(fn){
      suites[0].beforeAll(fn);
    };

    /**
     * Execute after running tests.
     */

    context.after = function(fn){
      suites[0].afterAll(fn);
    };

    /**
     * Execute before each test case.
     */

    context.beforeEach = function(fn){
      suites[0].beforeEach(fn);
    };

    /**
     * Execute after each test case.
     */

    context.afterEach = function(fn){
      suites[0].afterEach(fn);
    };

    /**
     * Describe a "suite" with the given `title`
     * and callback `fn` containing nested suites
     * and/or tests.
     */

    context.describe = context.context = function(title, fn){
      var suite = Suite.create(suites[0], title);
      suites.unshift(suite);
      fn.call(suite);
      suites.shift();
      return suite;
    };

    /**
     * Pending describe.
     */

    context.xdescribe =
    context.xcontext =
    context.describe.skip = function(title, fn){
      var suite = Suite.create(suites[0], title);
      suite.pending = true;
      suites.unshift(suite);
      fn.call(suite);
      suites.shift();
    };

    /**
     * Exclusive suite.
     */

    context.describe.only = function(title, fn){
      var suite = context.describe(title, fn);
      mocha.grep(suite.fullTitle());
    };

    /**
     * Describe a specification or test-case
     * with the given `title` and callback `fn`
     * acting as a thunk.
     */

    context.it = context.specify = function(title, fn){
      var suite = suites[0];
      if (suite.pending) var fn = null;
      var test = new Test(title, fn);
      suite.addTest(test);
      return test;
    };

    /**
     * Exclusive test-case.
     */

    context.it.only = function(title, fn){
      var test = context.it(title, fn);
      mocha.grep(test.fullTitle());
    };

    /**
     * Pending test case.
     */

    context.xit =
    context.xspecify =
    context.it.skip = function(title){
      context.it(title);
    };
  });
};

}); // module: interfaces/bdd.js

require.register("interfaces/exports.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Suite = require('../suite')
  , Test = require('../test');

/**
 * TDD-style interface:
 *
 *     exports.Array = {
 *       '#indexOf()': {
 *         'should return -1 when the value is not present': function(){
 *
 *         },
 *
 *         'should return the correct index when the value is present': function(){
 *
 *         }
 *       }
 *     };
 *
 */

module.exports = function(suite){
  var suites = [suite];

  suite.on('require', visit);

  function visit(obj) {
    var suite;
    for (var key in obj) {
      if ('function' == typeof obj[key]) {
        var fn = obj[key];
        switch (key) {
          case 'before':
            suites[0].beforeAll(fn);
            break;
          case 'after':
            suites[0].afterAll(fn);
            break;
          case 'beforeEach':
            suites[0].beforeEach(fn);
            break;
          case 'afterEach':
            suites[0].afterEach(fn);
            break;
          default:
            suites[0].addTest(new Test(key, fn));
        }
      } else {
        var suite = Suite.create(suites[0], key);
        suites.unshift(suite);
        visit(obj[key]);
        suites.shift();
      }
    }
  }
};

}); // module: interfaces/exports.js

require.register("interfaces/index.js", function(module, exports, require){

exports.bdd = require('./bdd');
exports.tdd = require('./tdd');
exports.qunit = require('./qunit');
exports.exports = require('./exports');

}); // module: interfaces/index.js

require.register("interfaces/qunit.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Suite = require('../suite')
  , Test = require('../test');

/**
 * QUnit-style interface:
 *
 *     suite('Array');
 *
 *     test('#length', function(){
 *       var arr = [1,2,3];
 *       ok(arr.length == 3);
 *     });
 *
 *     test('#indexOf()', function(){
 *       var arr = [1,2,3];
 *       ok(arr.indexOf(1) == 0);
 *       ok(arr.indexOf(2) == 1);
 *       ok(arr.indexOf(3) == 2);
 *     });
 *
 *     suite('String');
 *
 *     test('#length', function(){
 *       ok('foo'.length == 3);
 *     });
 *
 */

module.exports = function(suite){
  var suites = [suite];

  suite.on('pre-require', function(context){

    /**
     * Execute before running tests.
     */

    context.before = function(fn){
      suites[0].beforeAll(fn);
    };

    /**
     * Execute after running tests.
     */

    context.after = function(fn){
      suites[0].afterAll(fn);
    };

    /**
     * Execute before each test case.
     */

    context.beforeEach = function(fn){
      suites[0].beforeEach(fn);
    };

    /**
     * Execute after each test case.
     */

    context.afterEach = function(fn){
      suites[0].afterEach(fn);
    };

    /**
     * Describe a "suite" with the given `title`.
     */

    context.suite = function(title){
      if (suites.length > 1) suites.shift();
      var suite = Suite.create(suites[0], title);
      suites.unshift(suite);
    };

    /**
     * Describe a specification or test-case
     * with the given `title` and callback `fn`
     * acting as a thunk.
     */

    context.test = function(title, fn){
      suites[0].addTest(new Test(title, fn));
    };
  });
};

}); // module: interfaces/qunit.js

require.register("interfaces/tdd.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Suite = require('../suite')
  , Test = require('../test');

/**
 * TDD-style interface:
 *
 *      suite('Array', function(){
 *        suite('#indexOf()', function(){
 *          suiteSetup(function(){
 *
 *          });
 *
 *          test('should return -1 when not present', function(){
 *
 *          });
 *
 *          test('should return the index when present', function(){
 *
 *          });
 *
 *          suiteTeardown(function(){
 *
 *          });
 *        });
 *      });
 *
 */

module.exports = function(suite){
  var suites = [suite];

  suite.on('pre-require', function(context, file, mocha){

    /**
     * Execute before each test case.
     */

    context.setup = function(fn){
      suites[0].beforeEach(fn);
    };

    /**
     * Execute after each test case.
     */

    context.teardown = function(fn){
      suites[0].afterEach(fn);
    };

    /**
     * Execute before the suite.
     */

    context.suiteSetup = function(fn){
      suites[0].beforeAll(fn);
    };

    /**
     * Execute after the suite.
     */

    context.suiteTeardown = function(fn){
      suites[0].afterAll(fn);
    };

    /**
     * Describe a "suite" with the given `title`
     * and callback `fn` containing nested suites
     * and/or tests.
     */

    context.suite = function(title, fn){
      var suite = Suite.create(suites[0], title);
      suites.unshift(suite);
      fn.call(suite);
      suites.shift();
      return suite;
    };

    /**
     * Exclusive test-case.
     */

    context.suite.only = function(title, fn){
      var suite = context.suite(title, fn);
      mocha.grep(suite.fullTitle());
    };

    /**
     * Describe a specification or test-case
     * with the given `title` and callback `fn`
     * acting as a thunk.
     */

    context.test = function(title, fn){
      var test = new Test(title, fn);
      suites[0].addTest(test);
      return test;
    };

    /**
     * Exclusive test-case.
     */

    context.test.only = function(title, fn){
      var test = context.test(title, fn);
      mocha.grep(test.fullTitle());
    };

    /**
     * Pending test case.
     */

    context.test.skip = function(title){
      context.test(title);
    };
  });
};

}); // module: interfaces/tdd.js

require.register("mocha.js", function(module, exports, require){
/*!
 * mocha
 * Copyright(c) 2011 TJ Holowaychuk <tj@vision-media.ca>
 * MIT Licensed
 */

/**
 * Module dependencies.
 */

var path = require('browser/path')
  , utils = require('./utils');

/**
 * Expose `Mocha`.
 */

exports = module.exports = Mocha;

/**
 * Expose internals.
 */

exports.utils = utils;
exports.interfaces = require('./interfaces');
exports.reporters = require('./reporters');
exports.Runnable = require('./runnable');
exports.Context = require('./context');
exports.Runner = require('./runner');
exports.Suite = require('./suite');
exports.Hook = require('./hook');
exports.Test = require('./test');

/**
 * Return image `name` path.
 *
 * @param {String} name
 * @return {String}
 * @api private
 */

function image(name) {
  return __dirname + '/../images/' + name + '.png';
}

/**
 * Setup mocha with `options`.
 *
 * Options:
 *
 *   - `ui` name "bdd", "tdd", "exports" etc
 *   - `reporter` reporter instance, defaults to `mocha.reporters.Dot`
 *   - `globals` array of accepted globals
 *   - `timeout` timeout in milliseconds
 *   - `bail` bail on the first test failure
 *   - `slow` milliseconds to wait before considering a test slow
 *   - `ignoreLeaks` ignore global leaks
 *   - `grep` string or regexp to filter tests with
 *
 * @param {Object} options
 * @api public
 */

function Mocha(options) {
  options = options || {};
  this.files = [];
  this.options = options;
  this.grep(options.grep);
  this.suite = new exports.Suite('', new exports.Context);
  this.ui(options.ui);
  this.bail(options.bail);
  this.reporter(options.reporter);
  if (options.timeout) this.timeout(options.timeout);
  if (options.slow) this.slow(options.slow);
}

/**
 * Enable or disable bailing on the first failure.
 *
 * @param {Boolean} [bail]
 * @api public
 */

Mocha.prototype.bail = function(bail){
  if (0 == arguments.length) bail = true;
  this.suite.bail(bail);
  return this;
};

/**
 * Add test `file`.
 *
 * @param {String} file
 * @api public
 */

Mocha.prototype.addFile = function(file){
  this.files.push(file);
  return this;
};

/**
 * Set reporter to `reporter`, defaults to "dot".
 *
 * @param {String|Function} reporter name or constructor
 * @api public
 */

Mocha.prototype.reporter = function(reporter){
  if ('function' == typeof reporter) {
    this._reporter = reporter;
  } else {
    reporter = reporter || 'dot';
    try {
      this._reporter = require('./reporters/' + reporter);
    } catch (err) {
      this._reporter = require(reporter);
    }
    if (!this._reporter) throw new Error('invalid reporter "' + reporter + '"');
  }
  return this;
};

/**
 * Set test UI `name`, defaults to "bdd".
 *
 * @param {String} bdd
 * @api public
 */

Mocha.prototype.ui = function(name){
  name = name || 'bdd';
  this._ui = exports.interfaces[name];
  if (!this._ui) throw new Error('invalid interface "' + name + '"');
  this._ui = this._ui(this.suite);
  return this;
};

/**
 * Load registered files.
 *
 * @api private
 */

Mocha.prototype.loadFiles = function(fn){
  var self = this;
  var suite = this.suite;
  var pending = this.files.length;
  this.files.forEach(function(file){
    file = path.resolve(file);
    suite.emit('pre-require', global, file, self);
    suite.emit('require', require(file), file, self);
    suite.emit('post-require', global, file, self);
    --pending || (fn && fn());
  });
};

/**
 * Enable growl support.
 *
 * @api private
 */

Mocha.prototype._growl = function(runner, reporter) {
  var notify = require('growl');

  runner.on('end', function(){
    var stats = reporter.stats;
    if (stats.failures) {
      var msg = stats.failures + ' of ' + runner.total + ' tests failed';
      notify(msg, { name: 'mocha', title: 'Failed', image: image('error') });
    } else {
      notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', {
          name: 'mocha'
        , title: 'Passed'
        , image: image('ok')
      });
    }
  });
};

/**
 * Add regexp to grep, if `re` is a string it is escaped.
 *
 * @param {RegExp|String} re
 * @return {Mocha}
 * @api public
 */

Mocha.prototype.grep = function(re){
  this.options.grep = 'string' == typeof re
    ? new RegExp(utils.escapeRegexp(re))
    : re;
  return this;
};

/**
 * Invert `.grep()` matches.
 *
 * @return {Mocha}
 * @api public
 */

Mocha.prototype.invert = function(){
  this.options.invert = true;
  return this;
};

/**
 * Ignore global leaks.
 *
 * @return {Mocha}
 * @api public
 */

Mocha.prototype.ignoreLeaks = function(){
  this.options.ignoreLeaks = true;
  return this;
};

/**
 * Enable global leak checking.
 *
 * @return {Mocha}
 * @api public
 */

Mocha.prototype.checkLeaks = function(){
  this.options.ignoreLeaks = false;
  return this;
};

/**
 * Enable growl support.
 *
 * @return {Mocha}
 * @api public
 */

Mocha.prototype.growl = function(){
  this.options.growl = true;
  return this;
};

/**
 * Ignore `globals` array or string.
 *
 * @param {Array|String} globals
 * @return {Mocha}
 * @api public
 */

Mocha.prototype.globals = function(globals){
  this.options.globals = (this.options.globals || []).concat(globals);
  return this;
};

/**
 * Set the timeout in milliseconds.
 *
 * @param {Number} timeout
 * @return {Mocha}
 * @api public
 */

Mocha.prototype.timeout = function(timeout){
  this.suite.timeout(timeout);
  return this;
};

/**
 * Set slowness threshold in milliseconds.
 *
 * @param {Number} slow
 * @return {Mocha}
 * @api public
 */

Mocha.prototype.slow = function(slow){
  this.suite.slow(slow);
  return this;
};

/**
 * Makes all tests async (accepting a callback)
 *
 * @return {Mocha}
 * @api public
 */

Mocha.prototype.asyncOnly = function(){
  this.options.asyncOnly = true;
  return this;
};

/**
 * Run tests and invoke `fn()` when complete.
 *
 * @param {Function} fn
 * @return {Runner}
 * @api public
 */

Mocha.prototype.run = function(fn){
  if (this.files.length) this.loadFiles();
  var suite = this.suite;
  var options = this.options;
  var runner = new exports.Runner(suite);
  var reporter = new this._reporter(runner);
  runner.ignoreLeaks = false !== options.ignoreLeaks;
  runner.asyncOnly = options.asyncOnly;
  if (options.grep) runner.grep(options.grep, options.invert);
  if (options.globals) runner.globals(options.globals);
  if (options.growl) this._growl(runner, reporter);
  return runner.run(fn);
};

}); // module: mocha.js

require.register("ms.js", function(module, exports, require){

/**
 * Helpers.
 */

var s = 1000;
var m = s * 60;
var h = m * 60;
var d = h * 24;

/**
 * Parse or format the given `val`.
 *
 * @param {String|Number} val
 * @return {String|Number}
 * @api public
 */

module.exports = function(val){
  if ('string' == typeof val) return parse(val);
  return format(val);
}

/**
 * Parse the given `str` and return milliseconds.
 *
 * @param {String} str
 * @return {Number}
 * @api private
 */

function parse(str) {
  var m = /^((?:\d+)?\.?\d+) *(ms|seconds?|s|minutes?|m|hours?|h|days?|d|years?|y)?$/i.exec(str);
  if (!m) return;
  var n = parseFloat(m[1]);
  var type = (m[2] || 'ms').toLowerCase();
  switch (type) {
    case 'years':
    case 'year':
    case 'y':
      return n * 31557600000;
    case 'days':
    case 'day':
    case 'd':
      return n * 86400000;
    case 'hours':
    case 'hour':
    case 'h':
      return n * 3600000;
    case 'minutes':
    case 'minute':
    case 'm':
      return n * 60000;
    case 'seconds':
    case 'second':
    case 's':
      return n * 1000;
    case 'ms':
      return n;
  }
}

/**
 * Format the given `ms`.
 *
 * @param {Number} ms
 * @return {String}
 * @api public
 */

function format(ms) {
  if (ms == d) return Math.round(ms / d) + ' day';
  if (ms > d) return Math.round(ms / d) + ' days';
  if (ms == h) return Math.round(ms / h) + ' hour';
  if (ms > h) return Math.round(ms / h) + ' hours';
  if (ms == m) return Math.round(ms / m) + ' minute';
  if (ms > m) return Math.round(ms / m) + ' minutes';
  if (ms == s) return Math.round(ms / s) + ' second';
  if (ms > s) return Math.round(ms / s) + ' seconds';
  return ms + ' ms';
}
}); // module: ms.js

require.register("reporters/base.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var tty = require('browser/tty')
  , diff = require('browser/diff')
  , ms = require('../ms');

/**
 * Save timer references to avoid Sinon interfering (see GH-237).
 */

var Date = global.Date
  , setTimeout = global.setTimeout
  , setInterval = global.setInterval
  , clearTimeout = global.clearTimeout
  , clearInterval = global.clearInterval;

/**
 * Check if both stdio streams are associated with a tty.
 */

var isatty = tty.isatty(1) && tty.isatty(2);

/**
 * Expose `Base`.
 */

exports = module.exports = Base;

/**
 * Enable coloring by default.
 */

exports.useColors = isatty;

/**
 * Default color map.
 */

exports.colors = {
    'pass': 90
  , 'fail': 31
  , 'bright pass': 92
  , 'bright fail': 91
  , 'bright yellow': 93
  , 'pending': 36
  , 'suite': 0
  , 'error title': 0
  , 'error message': 31
  , 'error stack': 90
  , 'checkmark': 32
  , 'fast': 90
  , 'medium': 33
  , 'slow': 31
  , 'green': 32
  , 'light': 90
  , 'diff gutter': 90
  , 'diff added': 42
  , 'diff removed': 41
};

/**
 * Default symbol map.
 */

exports.symbols = {
  ok: '✓',
  err: '✖',
  dot: '․'
};

// With node.js on Windows: use symbols available in terminal default fonts
if ('win32' == process.platform) {
  exports.symbols.ok = '\u221A';
  exports.symbols.err = '\u00D7';
  exports.symbols.dot = '.';
}

/**
 * Color `str` with the given `type`,
 * allowing colors to be disabled,
 * as well as user-defined color
 * schemes.
 *
 * @param {String} type
 * @param {String} str
 * @return {String}
 * @api private
 */

var color = exports.color = function(type, str) {
  if (!exports.useColors) return str;
  return '\u001b[' + exports.colors[type] + 'm' + str + '\u001b[0m';
};

/**
 * Expose term window size, with some
 * defaults for when stderr is not a tty.
 */

exports.window = {
  width: isatty
    ? process.stdout.getWindowSize
      ? process.stdout.getWindowSize(1)[0]
      : tty.getWindowSize()[1]
    : 75
};

/**
 * Expose some basic cursor interactions
 * that are common among reporters.
 */

exports.cursor = {
  hide: function(){
    process.stdout.write('\u001b[?25l');
  },

  show: function(){
    process.stdout.write('\u001b[?25h');
  },

  deleteLine: function(){
    process.stdout.write('\u001b[2K');
  },

  beginningOfLine: function(){
    process.stdout.write('\u001b[0G');
  },

  CR: function(){
    exports.cursor.deleteLine();
    exports.cursor.beginningOfLine();
  }
};

/**
 * Outut the given `failures` as a list.
 *
 * @param {Array} failures
 * @api public
 */

exports.list = function(failures){
  console.error();
  failures.forEach(function(test, i){
    // format
    var fmt = color('error title', '  %s) %s:\n')
      + color('error message', '     %s')
      + color('error stack', '\n%s\n');

    // msg
    var err = test.err
      , message = err.message || ''
      , stack = err.stack || message
      , index = stack.indexOf(message) + message.length
      , msg = stack.slice(0, index)
      , actual = err.actual
      , expected = err.expected
      , escape = true;

    // explicitly show diff
    if (err.showDiff) {
      escape = false;
      err.actual = actual = JSON.stringify(actual, null, 2);
      err.expected = expected = JSON.stringify(expected, null, 2);
    }

    // actual / expected diff
    if ('string' == typeof actual && 'string' == typeof expected) {
      var len = Math.max(actual.length, expected.length);

      if (len < 20) msg = errorDiff(err, 'Chars', escape);
      else msg = errorDiff(err, 'Words', escape);

      // linenos
      var lines = msg.split('\n');
      if (lines.length > 4) {
        var width = String(lines.length).length;
        msg = lines.map(function(str, i){
          return pad(++i, width) + ' |' + ' ' + str;
        }).join('\n');
      }

      // legend
      msg = '\n'
        + color('diff removed', 'actual')
        + ' '
        + color('diff added', 'expected')
        + '\n\n'
        + msg
        + '\n';

      // indent
      msg = msg.replace(/^/gm, '      ');

      fmt = color('error title', '  %s) %s:\n%s')
        + color('error stack', '\n%s\n');
    }

    // indent stack trace without msg
    stack = stack.slice(index ? index + 1 : index)
      .replace(/^/gm, '  ');

    console.error(fmt, (i + 1), test.fullTitle(), msg, stack);
  });
};

/**
 * Initialize a new `Base` reporter.
 *
 * All other reporters generally
 * inherit from this reporter, providing
 * stats such as test duration, number
 * of tests passed / failed etc.
 *
 * @param {Runner} runner
 * @api public
 */

function Base(runner) {
  var self = this
    , stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 }
    , failures = this.failures = [];

  if (!runner) return;
  this.runner = runner;

  runner.stats = stats;

  runner.on('start', function(){
    stats.start = new Date;
  });

  runner.on('suite', function(suite){
    stats.suites = stats.suites || 0;
    suite.root || stats.suites++;
  });

  runner.on('test end', function(test){
    stats.tests = stats.tests || 0;
    stats.tests++;
  });

  runner.on('pass', function(test){
    stats.passes = stats.passes || 0;

    var medium = test.slow() / 2;
    test.speed = test.duration > test.slow()
      ? 'slow'
      : test.duration > medium
        ? 'medium'
        : 'fast';

    stats.passes++;
  });

  runner.on('fail', function(test, err){
    stats.failures = stats.failures || 0;
    stats.failures++;
    test.err = err;
    failures.push(test);
  });

  runner.on('end', function(){
    stats.end = new Date;
    stats.duration = new Date - stats.start;
  });

  runner.on('pending', function(){
    stats.pending++;
  });
}

/**
 * Output common epilogue used by many of
 * the bundled reporters.
 *
 * @api public
 */

Base.prototype.epilogue = function(){
  var stats = this.stats
    , fmt
    , tests;

  console.log();

  function pluralize(n) {
    return 1 == n ? 'test' : 'tests';
  }

  // failure
  if (stats.failures) {
    fmt = color('bright fail', '  ' + exports.symbols.err)
      + color('fail', ' %d of %d %s failed')
      + color('light', ':')

    console.error(fmt,
      stats.failures,
      this.runner.total,
      pluralize(this.runner.total));

    Base.list(this.failures);
    console.error();
    return;
  }

  // pass
  fmt = color('bright pass', ' ')
    + color('green', ' %d %s complete')
    + color('light', ' (%s)');

  console.log(fmt,
    stats.tests || 0,
    pluralize(stats.tests),
    ms(stats.duration));

  // pending
  if (stats.pending) {
    fmt = color('pending', ' ')
      + color('pending', ' %d %s pending');

    console.log(fmt, stats.pending, pluralize(stats.pending));
  }

  console.log();
};

/**
 * Pad the given `str` to `len`.
 *
 * @param {String} str
 * @param {String} len
 * @return {String}
 * @api private
 */

function pad(str, len) {
  str = String(str);
  return Array(len - str.length + 1).join(' ') + str;
}

/**
 * Return a character diff for `err`.
 *
 * @param {Error} err
 * @return {String}
 * @api private
 */

function errorDiff(err, type, escape) {
  return diff['diff' + type](err.actual, err.expected).map(function(str){
    if (escape) {
      str.value = str.value
        .replace(/\t/g, '<tab>')
        .replace(/\r/g, '<CR>')
        .replace(/\n/g, '<LF>\n');
    }
    if (str.added) return colorLines('diff added', str.value);
    if (str.removed) return colorLines('diff removed', str.value);
    return str.value;
  }).join('');
}

/**
 * Color lines for `str`, using the color `name`.
 *
 * @param {String} name
 * @param {String} str
 * @return {String}
 * @api private
 */

function colorLines(name, str) {
  return str.split('\n').map(function(str){
    return color(name, str);
  }).join('\n');
}

}); // module: reporters/base.js

require.register("reporters/doc.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base')
  , utils = require('../utils');

/**
 * Expose `Doc`.
 */

exports = module.exports = Doc;

/**
 * Initialize a new `Doc` reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function Doc(runner) {
  Base.call(this, runner);

  var self = this
    , stats = this.stats
    , total = runner.total
    , indents = 2;

  function indent() {
    return Array(indents).join('  ');
  }

  runner.on('suite', function(suite){
    if (suite.root) return;
    ++indents;
    console.log('%s<section class="suite">', indent());
    ++indents;
    console.log('%s<h1>%s</h1>', indent(), utils.escape(suite.title));
    console.log('%s<dl>', indent());
  });

  runner.on('suite end', function(suite){
    if (suite.root) return;
    console.log('%s</dl>', indent());
    --indents;
    console.log('%s</section>', indent());
    --indents;
  });

  runner.on('pass', function(test){
    console.log('%s  <dt>%s</dt>', indent(), utils.escape(test.title));
    var code = utils.escape(utils.clean(test.fn.toString()));
    console.log('%s  <dd><pre><code>%s</code></pre></dd>', indent(), code);
  });
}

}); // module: reporters/doc.js

require.register("reporters/dot.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base')
  , color = Base.color;

/**
 * Expose `Dot`.
 */

exports = module.exports = Dot;

/**
 * Initialize a new `Dot` matrix test reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function Dot(runner) {
  Base.call(this, runner);

  var self = this
    , stats = this.stats
    , width = Base.window.width * .75 | 0
    , n = 0;

  runner.on('start', function(){
    process.stdout.write('\n  ');
  });

  runner.on('pending', function(test){
    process.stdout.write(color('pending', Base.symbols.dot));
  });

  runner.on('pass', function(test){
    if (++n % width == 0) process.stdout.write('\n  ');
    if ('slow' == test.speed) {
      process.stdout.write(color('bright yellow', Base.symbols.dot));
    } else {
      process.stdout.write(color(test.speed, Base.symbols.dot));
    }
  });

  runner.on('fail', function(test, err){
    if (++n % width == 0) process.stdout.write('\n  ');
    process.stdout.write(color('fail', Base.symbols.dot));
  });

  runner.on('end', function(){
    console.log();
    self.epilogue();
  });
}

/**
 * Inherit from `Base.prototype`.
 */

function F(){};
F.prototype = Base.prototype;
Dot.prototype = new F;
Dot.prototype.constructor = Dot;

}); // module: reporters/dot.js

require.register("reporters/html-cov.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var JSONCov = require('./json-cov')
  , fs = require('browser/fs');

/**
 * Expose `HTMLCov`.
 */

exports = module.exports = HTMLCov;

/**
 * Initialize a new `JsCoverage` reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function HTMLCov(runner) {
  var jade = require('jade')
    , file = __dirname + '/templates/coverage.jade'
    , str = fs.readFileSync(file, 'utf8')
    , fn = jade.compile(str, { filename: file })
    , self = this;

  JSONCov.call(this, runner, false);

  runner.on('end', function(){
    process.stdout.write(fn({
        cov: self.cov
      , coverageClass: coverageClass
    }));
  });
}

/**
 * Return coverage class for `n`.
 *
 * @return {String}
 * @api private
 */

function coverageClass(n) {
  if (n >= 75) return 'high';
  if (n >= 50) return 'medium';
  if (n >= 25) return 'low';
  return 'terrible';
}
}); // module: reporters/html-cov.js

require.register("reporters/html.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base')
  , utils = require('../utils')
  , Progress = require('../browser/progress')
  , escape = utils.escape;

/**
 * Save timer references to avoid Sinon interfering (see GH-237).
 */

var Date = global.Date
  , setTimeout = global.setTimeout
  , setInterval = global.setInterval
  , clearTimeout = global.clearTimeout
  , clearInterval = global.clearInterval;

/**
 * Expose `Doc`.
 */

exports = module.exports = HTML;

/**
 * Stats template.
 */

var statsTemplate = '<ul id="mocha-stats">'
  + '<li class="progress"><canvas width="40" height="40"></canvas></li>'
  + '<li class="passes"><a href="#">passes:</a> <em>0</em></li>'
  + '<li class="failures"><a href="#">failures:</a> <em>0</em></li>'
  + '<li class="duration">duration: <em>0</em>s</li>'
  + '</ul>';

/**
 * Initialize a new `Doc` reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function HTML(runner, root) {
  Base.call(this, runner);

  var self = this
    , stats = this.stats
    , total = runner.total
    , stat = fragment(statsTemplate)
    , items = stat.getElementsByTagName('li')
    , passes = items[1].getElementsByTagName('em')[0]
    , passesLink = items[1].getElementsByTagName('a')[0]
    , failures = items[2].getElementsByTagName('em')[0]
    , failuresLink = items[2].getElementsByTagName('a')[0]
    , duration = items[3].getElementsByTagName('em')[0]
    , canvas = stat.getElementsByTagName('canvas')[0]
    , report = fragment('<ul id="mocha-report"></ul>')
    , stack = [report]
    , progress
    , ctx

  root = root || document.getElementById('mocha');

  if (canvas.getContext) {
    var ratio = window.devicePixelRatio || 1;
    canvas.style.width = canvas.width;
    canvas.style.height = canvas.height;
    canvas.width *= ratio;
    canvas.height *= ratio;
    ctx = canvas.getContext('2d');
    ctx.scale(ratio, ratio);
    progress = new Progress;
  }

  if (!root) return error('#mocha div missing, add it to your document');

  // pass toggle
  on(passesLink, 'click', function(){
    unhide();
    var name = /pass/.test(report.className) ? '' : ' pass';
    report.className = report.className.replace(/fail|pass/g, '') + name;
    if (report.className.trim()) hideSuitesWithout('test pass');
  });

  // failure toggle
  on(failuresLink, 'click', function(){
    unhide();
    var name = /fail/.test(report.className) ? '' : ' fail';
    report.className = report.className.replace(/fail|pass/g, '') + name;
    if (report.className.trim()) hideSuitesWithout('test fail');
  });

  root.appendChild(stat);
  root.appendChild(report);

  if (progress) progress.size(40);

  runner.on('suite', function(suite){
    if (suite.root) return;

    // suite
    var url = '?grep=' + encodeURIComponent(suite.fullTitle());
    var el = fragment('<li class="suite"><h1><a href="%s">%s</a></h1></li>', url, escape(suite.title));

    // container
    stack[0].appendChild(el);
    stack.unshift(document.createElement('ul'));
    el.appendChild(stack[0]);
  });

  runner.on('suite end', function(suite){
    if (suite.root) return;
    stack.shift();
  });

  runner.on('fail', function(test, err){
    if ('hook' == test.type) runner.emit('test end', test);
  });

  runner.on('test end', function(test){
    // TODO: add to stats
    var percent = stats.tests / this.total * 100 | 0;
    if (progress) progress.update(percent).draw(ctx);

    // update stats
    var ms = new Date - stats.start;
    text(passes, stats.passes);
    text(failures, stats.failures);
    text(duration, (ms / 1000).toFixed(2));

    // test
    if ('passed' == test.state) {
      var el = fragment('<li class="test pass %e"><h2>%e<span class="duration">%ems</span> <a href="?grep=%e" class="replay">‣</a></h2></li>', test.speed, test.title, test.duration, encodeURIComponent(test.fullTitle()));
    } else if (test.pending) {
      var el = fragment('<li class="test pass pending"><h2>%e</h2></li>', test.title);
    } else {
      var el = fragment('<li class="test fail"><h2>%e <a href="?grep=%e" class="replay">‣</a></h2></li>', test.title, encodeURIComponent(test.fullTitle()));
      var str = test.err.stack || test.err.toString();

      // FF / Opera do not add the message
      if (!~str.indexOf(test.err.message)) {
        str = test.err.message + '\n' + str;
      }

      // <=IE7 stringifies to [Object Error]. Since it can be overloaded, we
      // check for the result of the stringifying.
      if ('[object Error]' == str) str = test.err.message;

      // Safari doesn't give you a stack. Let's at least provide a source line.
      if (!test.err.stack && test.err.sourceURL && test.err.line !== undefined) {
        str += "\n(" + test.err.sourceURL + ":" + test.err.line + ")";
      }

      el.appendChild(fragment('<pre class="error">%e</pre>', str));
    }

    // toggle code
    // TODO: defer
    if (!test.pending) {
      var h2 = el.getElementsByTagName('h2')[0];

      on(h2, 'click', function(){
        pre.style.display = 'none' == pre.style.display
          ? 'block'
          : 'none';
      });

      var pre = fragment('<pre><code>%e</code></pre>', utils.clean(test.fn.toString()));
      el.appendChild(pre);
      pre.style.display = 'none';
    }

    // Don't call .appendChild if #mocha-report was already .shift()'ed off the stack.
    if (stack[0]) stack[0].appendChild(el);
  });
}

/**
 * Display error `msg`.
 */

function error(msg) {
  document.body.appendChild(fragment('<div id="mocha-error">%s</div>', msg));
}

/**
 * Return a DOM fragment from `html`.
 */

function fragment(html) {
  var args = arguments
    , div = document.createElement('div')
    , i = 1;

  div.innerHTML = html.replace(/%([se])/g, function(_, type){
    switch (type) {
      case 's': return String(args[i++]);
      case 'e': return escape(args[i++]);
    }
  });

  return div.firstChild;
}

/**
 * Check for suites that do not have elements
 * with `classname`, and hide them.
 */

function hideSuitesWithout(classname) {
  var suites = document.getElementsByClassName('suite');
  for (var i = 0; i < suites.length; i++) {
    var els = suites[i].getElementsByClassName(classname);
    if (0 == els.length) suites[i].className += ' hidden';
  }
}

/**
 * Unhide .hidden suites.
 */

function unhide() {
  var els = document.getElementsByClassName('suite hidden');
  for (var i = 0; i < els.length; ++i) {
    els[i].className = els[i].className.replace('suite hidden', 'suite');
  }
}

/**
 * Set `el` text to `str`.
 */

function text(el, str) {
  if (el.textContent) {
    el.textContent = str;
  } else {
    el.innerText = str;
  }
}

/**
 * Listen on `event` with callback `fn`.
 */

function on(el, event, fn) {
  if (el.addEventListener) {
    el.addEventListener(event, fn, false);
  } else {
    el.attachEvent('on' + event, fn);
  }
}

}); // module: reporters/html.js

require.register("reporters/index.js", function(module, exports, require){

exports.Base = require('./base');
exports.Dot = require('./dot');
exports.Doc = require('./doc');
exports.TAP = require('./tap');
exports.JSON = require('./json');
exports.HTML = require('./html');
exports.List = require('./list');
exports.Min = require('./min');
exports.Spec = require('./spec');
exports.Nyan = require('./nyan');
exports.XUnit = require('./xunit');
exports.Markdown = require('./markdown');
exports.Progress = require('./progress');
exports.Landing = require('./landing');
exports.JSONCov = require('./json-cov');
exports.HTMLCov = require('./html-cov');
exports.JSONStream = require('./json-stream');
exports.Teamcity = require('./teamcity');

}); // module: reporters/index.js

require.register("reporters/json-cov.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base');

/**
 * Expose `JSONCov`.
 */

exports = module.exports = JSONCov;

/**
 * Initialize a new `JsCoverage` reporter.
 *
 * @param {Runner} runner
 * @param {Boolean} output
 * @api public
 */

function JSONCov(runner, output) {
  var self = this
    , output = 1 == arguments.length ? true : output;

  Base.call(this, runner);

  var tests = []
    , failures = []
    , passes = [];

  runner.on('test end', function(test){
    tests.push(test);
  });

  runner.on('pass', function(test){
    passes.push(test);
  });

  runner.on('fail', function(test){
    failures.push(test);
  });

  runner.on('end', function(){
    var cov = global._$jscoverage || {};
    var result = self.cov = map(cov);
    result.stats = self.stats;
    result.tests = tests.map(clean);
    result.failures = failures.map(clean);
    result.passes = passes.map(clean);
    if (!output) return;
    process.stdout.write(JSON.stringify(result, null, 2 ));
  });
}

/**
 * Map jscoverage data to a JSON structure
 * suitable for reporting.
 *
 * @param {Object} cov
 * @return {Object}
 * @api private
 */

function map(cov) {
  var ret = {
      instrumentation: 'node-jscoverage'
    , sloc: 0
    , hits: 0
    , misses: 0
    , coverage: 0
    , files: []
  };

  for (var filename in cov) {
    var data = coverage(filename, cov[filename]);
    ret.files.push(data);
    ret.hits += data.hits;
    ret.misses += data.misses;
    ret.sloc += data.sloc;
  }

  ret.files.sort(function(a, b) {
    return a.filename.localeCompare(b.filename);
  });

  if (ret.sloc > 0) {
    ret.coverage = (ret.hits / ret.sloc) * 100;
  }

  return ret;
};

/**
 * Map jscoverage data for a single source file
 * to a JSON structure suitable for reporting.
 *
 * @param {String} filename name of the source file
 * @param {Object} data jscoverage coverage data
 * @return {Object}
 * @api private
 */

function coverage(filename, data) {
  var ret = {
    filename: filename,
    coverage: 0,
    hits: 0,
    misses: 0,
    sloc: 0,
    source: {}
  };

  data.source.forEach(function(line, num){
    num++;

    if (data[num] === 0) {
      ret.misses++;
      ret.sloc++;
    } else if (data[num] !== undefined) {
      ret.hits++;
      ret.sloc++;
    }

    ret.source[num] = {
        source: line
      , coverage: data[num] === undefined
        ? ''
        : data[num]
    };
  });

  ret.coverage = ret.hits / ret.sloc * 100;

  return ret;
}

/**
 * Return a plain-object representation of `test`
 * free of cyclic properties etc.
 *
 * @param {Object} test
 * @return {Object}
 * @api private
 */

function clean(test) {
  return {
      title: test.title
    , fullTitle: test.fullTitle()
    , duration: test.duration
  }
}

}); // module: reporters/json-cov.js

require.register("reporters/json-stream.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base')
  , color = Base.color;

/**
 * Expose `List`.
 */

exports = module.exports = List;

/**
 * Initialize a new `List` test reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function List(runner) {
  Base.call(this, runner);

  var self = this
    , stats = this.stats
    , total = runner.total;

  runner.on('start', function(){
    console.log(JSON.stringify(['start', { total: total }]));
  });

  runner.on('pass', function(test){
    console.log(JSON.stringify(['pass', clean(test)]));
  });

  runner.on('fail', function(test, err){
    console.log(JSON.stringify(['fail', clean(test)]));
  });

  runner.on('end', function(){
    process.stdout.write(JSON.stringify(['end', self.stats]));
  });
}

/**
 * Return a plain-object representation of `test`
 * free of cyclic properties etc.
 *
 * @param {Object} test
 * @return {Object}
 * @api private
 */

function clean(test) {
  return {
      title: test.title
    , fullTitle: test.fullTitle()
    , duration: test.duration
  }
}
}); // module: reporters/json-stream.js

require.register("reporters/json.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base')
  , cursor = Base.cursor
  , color = Base.color;

/**
 * Expose `JSON`.
 */

exports = module.exports = JSONReporter;

/**
 * Initialize a new `JSON` reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function JSONReporter(runner) {
  var self = this;
  Base.call(this, runner);

  var tests = []
    , failures = []
    , passes = [];

  runner.on('test end', function(test){
    tests.push(test);
  });

  runner.on('pass', function(test){
    passes.push(test);
  });

  runner.on('fail', function(test){
    failures.push(test);
  });

  runner.on('end', function(){
    var obj = {
        stats: self.stats
      , tests: tests.map(clean)
      , failures: failures.map(clean)
      , passes: passes.map(clean)
    };

    process.stdout.write(JSON.stringify(obj, null, 2));
  });
}

/**
 * Return a plain-object representation of `test`
 * free of cyclic properties etc.
 *
 * @param {Object} test
 * @return {Object}
 * @api private
 */

function clean(test) {
  return {
      title: test.title
    , fullTitle: test.fullTitle()
    , duration: test.duration
  }
}
}); // module: reporters/json.js

require.register("reporters/landing.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base')
  , cursor = Base.cursor
  , color = Base.color;

/**
 * Expose `Landing`.
 */

exports = module.exports = Landing;

/**
 * Airplane color.
 */

Base.colors.plane = 0;

/**
 * Airplane crash color.
 */

Base.colors['plane crash'] = 31;

/**
 * Runway color.
 */

Base.colors.runway = 90;

/**
 * Initialize a new `Landing` reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function Landing(runner) {
  Base.call(this, runner);

  var self = this
    , stats = this.stats
    , width = Base.window.width * .75 | 0
    , total = runner.total
    , stream = process.stdout
    , plane = color('plane', '✈')
    , crashed = -1
    , n = 0;

  function runway() {
    var buf = Array(width).join('-');
    return '  ' + color('runway', buf);
  }

  runner.on('start', function(){
    stream.write('\n  ');
    cursor.hide();
  });

  runner.on('test end', function(test){
    // check if the plane crashed
    var col = -1 == crashed
      ? width * ++n / total | 0
      : crashed;

    // show the crash
    if ('failed' == test.state) {
      plane = color('plane crash', '✈');
      crashed = col;
    }

    // render landing strip
    stream.write('\u001b[4F\n\n');
    stream.write(runway());
    stream.write('\n  ');
    stream.write(color('runway', Array(col).join('⋅')));
    stream.write(plane)
    stream.write(color('runway', Array(width - col).join('⋅') + '\n'));
    stream.write(runway());
    stream.write('\u001b[0m');
  });

  runner.on('end', function(){
    cursor.show();
    console.log();
    self.epilogue();
  });
}

/**
 * Inherit from `Base.prototype`.
 */

function F(){};
F.prototype = Base.prototype;
Landing.prototype = new F;
Landing.prototype.constructor = Landing;

}); // module: reporters/landing.js

require.register("reporters/list.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base')
  , cursor = Base.cursor
  , color = Base.color;

/**
 * Expose `List`.
 */

exports = module.exports = List;

/**
 * Initialize a new `List` test reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function List(runner) {
  Base.call(this, runner);

  var self = this
    , stats = this.stats
    , n = 0;

  runner.on('start', function(){
    console.log();
  });

  runner.on('test', function(test){
    process.stdout.write(color('pass', '    ' + test.fullTitle() + ': '));
  });

  runner.on('pending', function(test){
    var fmt = color('checkmark', '  -')
      + color('pending', ' %s');
    console.log(fmt, test.fullTitle());
  });

  runner.on('pass', function(test){
    var fmt = color('checkmark', '  '+Base.symbols.dot)
      + color('pass', ' %s: ')
      + color(test.speed, '%dms');
    cursor.CR();
    console.log(fmt, test.fullTitle(), test.duration);
  });

  runner.on('fail', function(test, err){
    cursor.CR();
    console.log(color('fail', '  %d) %s'), ++n, test.fullTitle());
  });

  runner.on('end', self.epilogue.bind(self));
}

/**
 * Inherit from `Base.prototype`.
 */

function F(){};
F.prototype = Base.prototype;
List.prototype = new F;
List.prototype.constructor = List;


}); // module: reporters/list.js

require.register("reporters/markdown.js", function(module, exports, require){
/**
 * Module dependencies.
 */

var Base = require('./base')
  , utils = require('../utils');

/**
 * Expose `Markdown`.
 */

exports = module.exports = Markdown;

/**
 * Initialize a new `Markdown` reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function Markdown(runner) {
  Base.call(this, runner);

  var self = this
    , stats = this.stats
    , level = 0
    , buf = '';

  function title(str) {
    return Array(level).join('#') + ' ' + str;
  }

  function indent() {
    return Array(level).join('  ');
  }

  function mapTOC(suite, obj) {
    var ret = obj;
    obj = obj[suite.title] = obj[suite.title] || { suite: suite };
    suite.suites.forEach(function(suite){
      mapTOC(suite, obj);
    });
    return ret;
  }

  function stringifyTOC(obj, level) {
    ++level;
    var buf = '';
    var link;
    for (var key in obj) {
      if ('suite' == key) continue;
      if (key) link = ' - [' + key + '](#' + utils.slug(obj[key].suite.fullTitle()) + ')\n';
      if (key) buf += Array(level).join('  ') + link;
      buf += stringifyTOC(obj[key], level);
    }
    --level;
    return buf;
  }

  function generateTOC(suite) {
    var obj = mapTOC(suite, {});
    return stringifyTOC(obj, 0);
  }

  generateTOC(runner.suite);

  runner.on('suite', function(suite){
    ++level;
    var slug = utils.slug(suite.fullTitle());
    buf += '<a name="' + slug + '"></a>' + '\n';
    buf += title(suite.title) + '\n';
  });

  runner.on('suite end', function(suite){
    --level;
  });

  runner.on('pass', function(test){
    var code = utils.clean(test.fn.toString());
    buf += test.title + '.\n';
    buf += '\n```js\n';
    buf += code + '\n';
    buf += '```\n\n';
  });

  runner.on('end', function(){
    process.stdout.write('# TOC\n');
    process.stdout.write(generateTOC(runner.suite));
    process.stdout.write(buf);
  });
}
}); // module: reporters/markdown.js

require.register("reporters/min.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base');

/**
 * Expose `Min`.
 */

exports = module.exports = Min;

/**
 * Initialize a new `Min` minimal test reporter (best used with --watch).
 *
 * @param {Runner} runner
 * @api public
 */

function Min(runner) {
  Base.call(this, runner);

  runner.on('start', function(){
    // clear screen
    process.stdout.write('\u001b[2J');
    // set cursor position
    process.stdout.write('\u001b[1;3H');
  });

  runner.on('end', this.epilogue.bind(this));
}

/**
 * Inherit from `Base.prototype`.
 */

function F(){};
F.prototype = Base.prototype;
Min.prototype = new F;
Min.prototype.constructor = Min;


}); // module: reporters/min.js

require.register("reporters/nyan.js", function(module, exports, require){
/**
 * Module dependencies.
 */

var Base = require('./base')
  , color = Base.color;

/**
 * Expose `Dot`.
 */

exports = module.exports = NyanCat;

/**
 * Initialize a new `Dot` matrix test reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function NyanCat(runner) {
  Base.call(this, runner);

  var self = this
    , stats = this.stats
    , width = Base.window.width * .75 | 0
    , rainbowColors = this.rainbowColors = self.generateColors()
    , colorIndex = this.colorIndex = 0
    , numerOfLines = this.numberOfLines = 4
    , trajectories = this.trajectories = [[], [], [], []]
    , nyanCatWidth = this.nyanCatWidth = 11
    , trajectoryWidthMax = this.trajectoryWidthMax = (width - nyanCatWidth)
    , scoreboardWidth = this.scoreboardWidth = 5
    , tick = this.tick = 0
    , n = 0;

  runner.on('start', function(){
    Base.cursor.hide();
    self.draw('start');
  });

  runner.on('pending', function(test){
    self.draw('pending');
  });

  runner.on('pass', function(test){
    self.draw('pass');
  });

  runner.on('fail', function(test, err){
    self.draw('fail');
  });

  runner.on('end', function(){
    Base.cursor.show();
    for (var i = 0; i < self.numberOfLines; i++) write('\n');
    self.epilogue();
  });
}

/**
 * Draw the nyan cat with runner `status`.
 *
 * @param {String} status
 * @api private
 */

NyanCat.prototype.draw = function(status){
  this.appendRainbow();
  this.drawScoreboard();
  this.drawRainbow();
  this.drawNyanCat(status);
  this.tick = !this.tick;
};

/**
 * Draw the "scoreboard" showing the number
 * of passes, failures and pending tests.
 *
 * @api private
 */

NyanCat.prototype.drawScoreboard = function(){
  var stats = this.stats;
  var colors = Base.colors;

  function draw(color, n) {
    write(' ');
    write('\u001b[' + color + 'm' + n + '\u001b[0m');
    write('\n');
  }

  draw(colors.green, stats.passes);
  draw(colors.fail, stats.failures);
  draw(colors.pending, stats.pending);
  write('\n');

  this.cursorUp(this.numberOfLines);
};

/**
 * Append the rainbow.
 *
 * @api private
 */

NyanCat.prototype.appendRainbow = function(){
  var segment = this.tick ? '_' : '-';
  var rainbowified = this.rainbowify(segment);

  for (var index = 0; index < this.numberOfLines; index++) {
    var trajectory = this.trajectories[index];
    if (trajectory.length >= this.trajectoryWidthMax) trajectory.shift();
    trajectory.push(rainbowified);
  }
};

/**
 * Draw the rainbow.
 *
 * @api private
 */

NyanCat.prototype.drawRainbow = function(){
  var self = this;

  this.trajectories.forEach(function(line, index) {
    write('\u001b[' + self.scoreboardWidth + 'C');
    write(line.join(''));
    write('\n');
  });

  this.cursorUp(this.numberOfLines);
};

/**
 * Draw the nyan cat with `status`.
 *
 * @param {String} status
 * @api private
 */

NyanCat.prototype.drawNyanCat = function(status) {
  var self = this;
  var startWidth = this.scoreboardWidth + this.trajectories[0].length;
  var color = '\u001b[' + startWidth + 'C';
  var padding = '';
  
  write(color);
  write('_,------,');
  write('\n');
  
  write(color);
  padding = self.tick ? '  ' : '   ';
  write('_|' + padding + '/\\_/\\ ');
  write('\n');
  
  write(color);
  padding = self.tick ? '_' : '__';
  var tail = self.tick ? '~' : '^';
  var face;
  switch (status) {
    case 'pass':
      face = '( ^ .^)';
      break;
    case 'fail':
      face = '( o .o)';
      break;
    default:
      face = '( - .-)';
  }
  write(tail + '|' + padding + face + ' ');
  write('\n');
  
  write(color);
  padding = self.tick ? ' ' : '  ';
  write(padding + '""  "" ');
  write('\n');

  this.cursorUp(this.numberOfLines);
};

/**
 * Move cursor up `n`.
 *
 * @param {Number} n
 * @api private
 */

NyanCat.prototype.cursorUp = function(n) {
  write('\u001b[' + n + 'A');
};

/**
 * Move cursor down `n`.
 *
 * @param {Number} n
 * @api private
 */

NyanCat.prototype.cursorDown = function(n) {
  write('\u001b[' + n + 'B');
};

/**
 * Generate rainbow colors.
 *
 * @return {Array}
 * @api private
 */

NyanCat.prototype.generateColors = function(){
  var colors = [];

  for (var i = 0; i < (6 * 7); i++) {
    var pi3 = Math.floor(Math.PI / 3);
    var n = (i * (1.0 / 6));
    var r = Math.floor(3 * Math.sin(n) + 3);
    var g = Math.floor(3 * Math.sin(n + 2 * pi3) + 3);
    var b = Math.floor(3 * Math.sin(n + 4 * pi3) + 3);
    colors.push(36 * r + 6 * g + b + 16);
  }

  return colors;
};

/**
 * Apply rainbow to the given `str`.
 *
 * @param {String} str
 * @return {String}
 * @api private
 */

NyanCat.prototype.rainbowify = function(str){
  var color = this.rainbowColors[this.colorIndex % this.rainbowColors.length];
  this.colorIndex += 1;
  return '\u001b[38;5;' + color + 'm' + str + '\u001b[0m';
};

/**
 * Stdout helper.
 */

function write(string) {
  process.stdout.write(string);
}

/**
 * Inherit from `Base.prototype`.
 */

function F(){};
F.prototype = Base.prototype;
NyanCat.prototype = new F;
NyanCat.prototype.constructor = NyanCat;


}); // module: reporters/nyan.js

require.register("reporters/progress.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base')
  , cursor = Base.cursor
  , color = Base.color;

/**
 * Expose `Progress`.
 */

exports = module.exports = Progress;

/**
 * General progress bar color.
 */

Base.colors.progress = 90;

/**
 * Initialize a new `Progress` bar test reporter.
 *
 * @param {Runner} runner
 * @param {Object} options
 * @api public
 */

function Progress(runner, options) {
  Base.call(this, runner);

  var self = this
    , options = options || {}
    , stats = this.stats
    , width = Base.window.width * .50 | 0
    , total = runner.total
    , complete = 0
    , max = Math.max;

  // default chars
  options.open = options.open || '[';
  options.complete = options.complete || '▬';
  options.incomplete = options.incomplete || Base.symbols.dot;
  options.close = options.close || ']';
  options.verbose = false;

  // tests started
  runner.on('start', function(){
    console.log();
    cursor.hide();
  });

  // tests complete
  runner.on('test end', function(){
    complete++;
    var incomplete = total - complete
      , percent = complete / total
      , n = width * percent | 0
      , i = width - n;

    cursor.CR();
    process.stdout.write('\u001b[J');
    process.stdout.write(color('progress', '  ' + options.open));
    process.stdout.write(Array(n).join(options.complete));
    process.stdout.write(Array(i).join(options.incomplete));
    process.stdout.write(color('progress', options.close));
    if (options.verbose) {
      process.stdout.write(color('progress', ' ' + complete + ' of ' + total));
    }
  });

  // tests are complete, output some stats
  // and the failures if any
  runner.on('end', function(){
    cursor.show();
    console.log();
    self.epilogue();
  });
}

/**
 * Inherit from `Base.prototype`.
 */

function F(){};
F.prototype = Base.prototype;
Progress.prototype = new F;
Progress.prototype.constructor = Progress;


}); // module: reporters/progress.js

require.register("reporters/spec.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base')
  , cursor = Base.cursor
  , color = Base.color;

/**
 * Expose `Spec`.
 */

exports = module.exports = Spec;

/**
 * Initialize a new `Spec` test reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function Spec(runner) {
  Base.call(this, runner);

  var self = this
    , stats = this.stats
    , indents = 0
    , n = 0;

  function indent() {
    return Array(indents).join('  ')
  }

  runner.on('start', function(){
    console.log();
  });

  runner.on('suite', function(suite){
    ++indents;
    console.log(color('suite', '%s%s'), indent(), suite.title);
  });

  runner.on('suite end', function(suite){
    --indents;
    if (1 == indents) console.log();
  });

  runner.on('test', function(test){
    process.stdout.write(indent() + color('pass', '  ◦ ' + test.title + ': '));
  });

  runner.on('pending', function(test){
    var fmt = indent() + color('pending', '  - %s');
    console.log(fmt, test.title);
  });

  runner.on('pass', function(test){
    if ('fast' == test.speed) {
      var fmt = indent()
        + color('checkmark', '  ' + Base.symbols.ok)
        + color('pass', ' %s ');
      cursor.CR();
      console.log(fmt, test.title);
    } else {
      var fmt = indent()
        + color('checkmark', '  ' + Base.symbols.ok)
        + color('pass', ' %s ')
        + color(test.speed, '(%dms)');
      cursor.CR();
      console.log(fmt, test.title, test.duration);
    }
  });

  runner.on('fail', function(test, err){
    cursor.CR();
    console.log(indent() + color('fail', '  %d) %s'), ++n, test.title);
  });

  runner.on('end', self.epilogue.bind(self));
}

/**
 * Inherit from `Base.prototype`.
 */

function F(){};
F.prototype = Base.prototype;
Spec.prototype = new F;
Spec.prototype.constructor = Spec;


}); // module: reporters/spec.js

require.register("reporters/tap.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base')
  , cursor = Base.cursor
  , color = Base.color;

/**
 * Expose `TAP`.
 */

exports = module.exports = TAP;

/**
 * Initialize a new `TAP` reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function TAP(runner) {
  Base.call(this, runner);

  var self = this
    , stats = this.stats
    , n = 1
    , passes = 0
    , failures = 0;

  runner.on('start', function(){
    var total = runner.grepTotal(runner.suite);
    console.log('%d..%d', 1, total);
  });

  runner.on('test end', function(){
    ++n;
  });

  runner.on('pending', function(test){
    console.log('ok %d %s # SKIP -', n, title(test));
  });

  runner.on('pass', function(test){
    passes++;
    console.log('ok %d %s', n, title(test));
  });

  runner.on('fail', function(test, err){
    failures++;
    console.log('not ok %d %s', n, title(test));
    if (err.stack) console.log(err.stack.replace(/^/gm, '  '));
  });

  runner.on('end', function(){
    console.log('# tests ' + (passes + failures));
    console.log('# pass ' + passes);
    console.log('# fail ' + failures);
  });
}

/**
 * Return a TAP-safe title of `test`
 *
 * @param {Object} test
 * @return {String}
 * @api private
 */

function title(test) {
  return test.fullTitle().replace(/#/g, '');
}

}); // module: reporters/tap.js

require.register("reporters/teamcity.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base');

/**
 * Expose `Teamcity`.
 */

exports = module.exports = Teamcity;

/**
 * Initialize a new `Teamcity` reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function Teamcity(runner) {
  Base.call(this, runner);
  var stats = this.stats;

  runner.on('start', function() {
    console.log("##teamcity[testSuiteStarted name='mocha.suite']");
  });

  runner.on('test', function(test) {
    console.log("##teamcity[testStarted name='" + escape(test.fullTitle()) + "']");
  });

  runner.on('fail', function(test, err) {
    console.log("##teamcity[testFailed name='" + escape(test.fullTitle()) + "' message='" + escape(err.message) + "']");
  });

  runner.on('pending', function(test) {
    console.log("##teamcity[testIgnored name='" + escape(test.fullTitle()) + "' message='pending']");
  });

  runner.on('test end', function(test) {
    console.log("##teamcity[testFinished name='" + escape(test.fullTitle()) + "' duration='" + test.duration + "']");
  });

  runner.on('end', function() {
    console.log("##teamcity[testSuiteFinished name='mocha.suite' duration='" + stats.duration + "']");
  });
}

/**
 * Escape the given `str`.
 */

function escape(str) {
  return str
    .replace(/\|/g, "||")
    .replace(/\n/g, "|n")
    .replace(/\r/g, "|r")
    .replace(/\[/g, "|[")
    .replace(/\]/g, "|]")
    .replace(/\u0085/g, "|x")
    .replace(/\u2028/g, "|l")
    .replace(/\u2029/g, "|p")
    .replace(/'/g, "|'");
}

}); // module: reporters/teamcity.js

require.register("reporters/xunit.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Base = require('./base')
  , utils = require('../utils')
  , escape = utils.escape;

/**
 * Save timer references to avoid Sinon interfering (see GH-237).
 */

var Date = global.Date
  , setTimeout = global.setTimeout
  , setInterval = global.setInterval
  , clearTimeout = global.clearTimeout
  , clearInterval = global.clearInterval;

/**
 * Expose `XUnit`.
 */

exports = module.exports = XUnit;

/**
 * Initialize a new `XUnit` reporter.
 *
 * @param {Runner} runner
 * @api public
 */

function XUnit(runner) {
  Base.call(this, runner);
  var stats = this.stats
    , tests = []
    , self = this;

  runner.on('pass', function(test){
    tests.push(test);
  });

  runner.on('fail', function(test){
    tests.push(test);
  });

  runner.on('end', function(){
    console.log(tag('testsuite', {
        name: 'Mocha Tests'
      , tests: stats.tests
      , failures: stats.failures
      , errors: stats.failures
      , skip: stats.tests - stats.failures - stats.passes
      , timestamp: (new Date).toUTCString()
      , time: stats.duration / 1000
    }, false));

    tests.forEach(test);
    console.log('</testsuite>');
  });
}

/**
 * Inherit from `Base.prototype`.
 */

function F(){};
F.prototype = Base.prototype;
XUnit.prototype = new F;
XUnit.prototype.constructor = XUnit;


/**
 * Output tag for the given `test.`
 */

function test(test) {
  var attrs = {
      classname: test.parent.fullTitle()
    , name: test.title
    , time: test.duration / 1000
  };

  if ('failed' == test.state) {
    var err = test.err;
    attrs.message = escape(err.message);
    console.log(tag('testcase', attrs, false, tag('failure', attrs, false, cdata(err.stack))));
  } else if (test.pending) {
    console.log(tag('testcase', attrs, false, tag('skipped', {}, true)));
  } else {
    console.log(tag('testcase', attrs, true) );
  }
}

/**
 * HTML tag helper.
 */

function tag(name, attrs, close, content) {
  var end = close ? '/>' : '>'
    , pairs = []
    , tag;

  for (var key in attrs) {
    pairs.push(key + '="' + escape(attrs[key]) + '"');
  }

  tag = '<' + name + (pairs.length ? ' ' + pairs.join(' ') : '') + end;
  if (content) tag += content + '</' + name + end;
  return tag;
}

/**
 * Return cdata escaped CDATA `str`.
 */

function cdata(str) {
  return '<![CDATA[' + escape(str) + ']]>';
}

}); // module: reporters/xunit.js

require.register("runnable.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var EventEmitter = require('browser/events').EventEmitter
  , debug = require('browser/debug')('mocha:runnable')
  , milliseconds = require('./ms');

/**
 * Save timer references to avoid Sinon interfering (see GH-237).
 */

var Date = global.Date
  , setTimeout = global.setTimeout
  , setInterval = global.setInterval
  , clearTimeout = global.clearTimeout
  , clearInterval = global.clearInterval;

/**
 * Object#toString().
 */

var toString = Object.prototype.toString;

/**
 * Expose `Runnable`.
 */

module.exports = Runnable;

/**
 * Initialize a new `Runnable` with the given `title` and callback `fn`.
 *
 * @param {String} title
 * @param {Function} fn
 * @api private
 */

function Runnable(title, fn) {
  this.title = title;
  this.fn = fn;
  this.async = fn && fn.length;
  this.sync = ! this.async;
  this._timeout = 2000;
  this._slow = 75;
  this.timedOut = false;
}

/**
 * Inherit from `EventEmitter.prototype`.
 */

function F(){};
F.prototype = EventEmitter.prototype;
Runnable.prototype = new F;
Runnable.prototype.constructor = Runnable;


/**
 * Set & get timeout `ms`.
 *
 * @param {Number|String} ms
 * @return {Runnable|Number} ms or self
 * @api private
 */

Runnable.prototype.timeout = function(ms){
  if (0 == arguments.length) return this._timeout;
  if ('string' == typeof ms) ms = milliseconds(ms);
  debug('timeout %d', ms);
  this._timeout = ms;
  if (this.timer) this.resetTimeout();
  return this;
};

/**
 * Set & get slow `ms`.
 *
 * @param {Number|String} ms
 * @return {Runnable|Number} ms or self
 * @api private
 */

Runnable.prototype.slow = function(ms){
  if (0 === arguments.length) return this._slow;
  if ('string' == typeof ms) ms = milliseconds(ms);
  debug('timeout %d', ms);
  this._slow = ms;
  return this;
};

/**
 * Return the full title generated by recursively
 * concatenating the parent's full title.
 *
 * @return {String}
 * @api public
 */

Runnable.prototype.fullTitle = function(){
  return this.parent.fullTitle() + ' ' + this.title;
};

/**
 * Clear the timeout.
 *
 * @api private
 */

Runnable.prototype.clearTimeout = function(){
  clearTimeout(this.timer);
};

/**
 * Inspect the runnable void of private properties.
 *
 * @return {String}
 * @api private
 */

Runnable.prototype.inspect = function(){
  return JSON.stringify(this, function(key, val){
    if ('_' == key[0]) return;
    if ('parent' == key) return '#<Suite>';
    if ('ctx' == key) return '#<Context>';
    return val;
  }, 2);
};

/**
 * Reset the timeout.
 *
 * @api private
 */

Runnable.prototype.resetTimeout = function(){
  var self = this
    , ms = this.timeout();

  this.clearTimeout();
  if (ms) {
    this.timer = setTimeout(function(){
      self.callback(new Error('timeout of ' + ms + 'ms exceeded'));
      self.timedOut = true;
    }, ms);
  }
};

/**
 * Run the test and invoke `fn(err)`.
 *
 * @param {Function} fn
 * @api private
 */

Runnable.prototype.run = function(fn){
  var self = this
    , ms = this.timeout()
    , start = new Date
    , ctx = this.ctx
    , finished
    , emitted;

  if (ctx) ctx.runnable(this);

  // timeout
  if (this.async) {
    if (ms) {
      this.timer = setTimeout(function(){
        done(new Error('timeout of ' + ms + 'ms exceeded'));
        self.timedOut = true;
      }, ms);
    }
  }

  // called multiple times
  function multiple(err) {
    if (emitted) return;
    emitted = true;
    self.emit('error', err || new Error('done() called multiple times'));
  }

  // finished
  function done(err) {
    if (self.timedOut) return;
    if (finished) return multiple(err);
    self.clearTimeout();
    self.duration = new Date - start;
    finished = true;
    fn(err);
  }

  // for .resetTimeout()
  this.callback = done;

  // async
  if (this.async) {
    try {
      this.fn.call(ctx, function(err){
        if (err instanceof Error || toString.call(err) === "[object Error]") return done(err);
        if (null != err) return done(new Error('done() invoked with non-Error: ' + err));
        done();
      });
    } catch (err) {
      done(err);
    }
    return;
  }

  if (this.asyncOnly) {
    return done(new Error('--async-only option in use without declaring `done()`'));
  }

  // sync
  try {
    if (!this.pending) this.fn.call(ctx);
    this.duration = new Date - start;
    fn();
  } catch (err) {
    fn(err);
  }
};

}); // module: runnable.js

require.register("runner.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var EventEmitter = require('browser/events').EventEmitter
  , debug = require('browser/debug')('mocha:runner')
  , Test = require('./test')
  , utils = require('./utils')
  , filter = utils.filter
  , keys = utils.keys;

/**
 * Non-enumerable globals.
 */

var globals = [
  'setTimeout',
  'clearTimeout',
  'setInterval',
  'clearInterval',
  'XMLHttpRequest',
  'Date'
];

/**
 * Expose `Runner`.
 */

module.exports = Runner;

/**
 * Initialize a `Runner` for the given `suite`.
 *
 * Events:
 *
 *   - `start`  execution started
 *   - `end`  execution complete
 *   - `suite`  (suite) test suite execution started
 *   - `suite end`  (suite) all tests (and sub-suites) have finished
 *   - `test`  (test) test execution started
 *   - `test end`  (test) test completed
 *   - `hook`  (hook) hook execution started
 *   - `hook end`  (hook) hook complete
 *   - `pass`  (test) test passed
 *   - `fail`  (test, err) test failed
 *
 * @api public
 */

function Runner(suite) {
  var self = this;
  this._globals = [];
  this.suite = suite;
  this.total = suite.total();
  this.failures = 0;
  this.on('test end', function(test){ self.checkGlobals(test); });
  this.on('hook end', function(hook){ self.checkGlobals(hook); });
  this.grep(/.*/);
  this.globals(this.globalProps().concat(['errno']));
}

/**
 * Wrapper for setImmediate, process.nextTick, or browser polyfill.
 *
 * @param {Function} fn
 * @api private
 */

Runner.immediately = global.setImmediate || process.nextTick;

/**
 * Inherit from `EventEmitter.prototype`.
 */

function F(){};
F.prototype = EventEmitter.prototype;
Runner.prototype = new F;
Runner.prototype.constructor = Runner;


/**
 * Run tests with full titles matching `re`. Updates runner.total
 * with number of tests matched.
 *
 * @param {RegExp} re
 * @param {Boolean} invert
 * @return {Runner} for chaining
 * @api public
 */

Runner.prototype.grep = function(re, invert){
  debug('grep %s', re);
  this._grep = re;
  this._invert = invert;
  this.total = this.grepTotal(this.suite);
  return this;
};

/**
 * Returns the number of tests matching the grep search for the
 * given suite.
 *
 * @param {Suite} suite
 * @return {Number}
 * @api public
 */

Runner.prototype.grepTotal = function(suite) {
  var self = this;
  var total = 0;

  suite.eachTest(function(test){
    var match = self._grep.test(test.fullTitle());
    if (self._invert) match = !match;
    if (match) total++;
  });

  return total;
};

/**
 * Return a list of global properties.
 *
 * @return {Array}
 * @api private
 */

Runner.prototype.globalProps = function() {
  var props = utils.keys(global);

  // non-enumerables
  for (var i = 0; i < globals.length; ++i) {
    if (~utils.indexOf(props, globals[i])) continue;
    props.push(globals[i]);
  }

  return props;
};

/**
 * Allow the given `arr` of globals.
 *
 * @param {Array} arr
 * @return {Runner} for chaining
 * @api public
 */

Runner.prototype.globals = function(arr){
  if (0 == arguments.length) return this._globals;
  debug('globals %j', arr);
  utils.forEach(arr, function(arr){
    this._globals.push(arr);
  }, this);
  return this;
};

/**
 * Check for global variable leaks.
 *
 * @api private
 */

Runner.prototype.checkGlobals = function(test){
  if (this.ignoreLeaks) return;
  var ok = this._globals;
  var globals = this.globalProps();
  var isNode = process.kill;
  var leaks;

  // check length - 2 ('errno' and 'location' globals)
  if (isNode && 1 == ok.length - globals.length) return
  else if (2 == ok.length - globals.length) return;

  leaks = filterLeaks(ok, globals);
  this._globals = this._globals.concat(leaks);

  if (leaks.length > 1) {
    this.fail(test, new Error('global leaks detected: ' + leaks.join(', ') + ''));
  } else if (leaks.length) {
    this.fail(test, new Error('global leak detected: ' + leaks[0]));
  }
};

/**
 * Fail the given `test`.
 *
 * @param {Test} test
 * @param {Error} err
 * @api private
 */

Runner.prototype.fail = function(test, err){
  ++this.failures;
  test.state = 'failed';

  if ('string' == typeof err) {
    err = new Error('the string "' + err + '" was thrown, throw an Error :)');
  }

  this.emit('fail', test, err);
};

/**
 * Fail the given `hook` with `err`.
 *
 * Hook failures (currently) hard-end due
 * to that fact that a failing hook will
 * surely cause subsequent tests to fail,
 * causing jumbled reporting.
 *
 * @param {Hook} hook
 * @param {Error} err
 * @api private
 */

Runner.prototype.failHook = function(hook, err){
  this.fail(hook, err);
  this.emit('end');
};

/**
 * Run hook `name` callbacks and then invoke `fn()`.
 *
 * @param {String} name
 * @param {Function} function
 * @api private
 */

Runner.prototype.hook = function(name, fn){
  var suite = this.suite
    , hooks = suite['_' + name]
    , self = this
    , timer;

  function next(i) {
    var hook = hooks[i];
    if (!hook) return fn();
    self.currentRunnable = hook;

    self.emit('hook', hook);

    hook.on('error', function(err){
      self.failHook(hook, err);
    });

    hook.run(function(err){
      hook.removeAllListeners('error');
      var testError = hook.error();
      if (testError) self.fail(self.test, testError);
      if (err) return self.failHook(hook, err);
      self.emit('hook end', hook);
      next(++i);
    });
  }

  Runner.immediately(function(){
    next(0);
  });
};

/**
 * Run hook `name` for the given array of `suites`
 * in order, and callback `fn(err)`.
 *
 * @param {String} name
 * @param {Array} suites
 * @param {Function} fn
 * @api private
 */

Runner.prototype.hooks = function(name, suites, fn){
  var self = this
    , orig = this.suite;

  function next(suite) {
    self.suite = suite;

    if (!suite) {
      self.suite = orig;
      return fn();
    }

    self.hook(name, function(err){
      if (err) {
        self.suite = orig;
        return fn(err);
      }

      next(suites.pop());
    });
  }

  next(suites.pop());
};

/**
 * Run hooks from the top level down.
 *
 * @param {String} name
 * @param {Function} fn
 * @api private
 */

Runner.prototype.hookUp = function(name, fn){
  var suites = [this.suite].concat(this.parents()).reverse();
  this.hooks(name, suites, fn);
};

/**
 * Run hooks from the bottom up.
 *
 * @param {String} name
 * @param {Function} fn
 * @api private
 */

Runner.prototype.hookDown = function(name, fn){
  var suites = [this.suite].concat(this.parents());
  this.hooks(name, suites, fn);
};

/**
 * Return an array of parent Suites from
 * closest to furthest.
 *
 * @return {Array}
 * @api private
 */

Runner.prototype.parents = function(){
  var suite = this.suite
    , suites = [];
  while (suite = suite.parent) suites.push(suite);
  return suites;
};

/**
 * Run the current test and callback `fn(err)`.
 *
 * @param {Function} fn
 * @api private
 */

Runner.prototype.runTest = function(fn){
  var test = this.test
    , self = this;

  if (this.asyncOnly) test.asyncOnly = true;

  try {
    test.on('error', function(err){
      self.fail(test, err);
    });
    test.run(fn);
  } catch (err) {
    fn(err);
  }
};

/**
 * Run tests in the given `suite` and invoke
 * the callback `fn()` when complete.
 *
 * @param {Suite} suite
 * @param {Function} fn
 * @api private
 */

Runner.prototype.runTests = function(suite, fn){
  var self = this
    , tests = suite.tests.slice()
    , test;

  function next(err) {
    // if we bail after first err
    if (self.failures && suite._bail) return fn();

    // next test
    test = tests.shift();

    // all done
    if (!test) return fn();

    // grep
    var match = self._grep.test(test.fullTitle());
    if (self._invert) match = !match;
    if (!match) return next();

    // pending
    if (test.pending) {
      self.emit('pending', test);
      self.emit('test end', test);
      return next();
    }

    // execute test and hook(s)
    self.emit('test', self.test = test);
    self.hookDown('beforeEach', function(){
      self.currentRunnable = self.test;
      self.runTest(function(err){
        test = self.test;

        if (err) {
          self.fail(test, err);
          self.emit('test end', test);
          return self.hookUp('afterEach', next);
        }

        test.state = 'passed';
        self.emit('pass', test);
        self.emit('test end', test);
        self.hookUp('afterEach', next);
      });
    });
  }

  this.next = next;
  next();
};

/**
 * Run the given `suite` and invoke the
 * callback `fn()` when complete.
 *
 * @param {Suite} suite
 * @param {Function} fn
 * @api private
 */

Runner.prototype.runSuite = function(suite, fn){
  var total = this.grepTotal(suite)
    , self = this
    , i = 0;

  debug('run suite %s', suite.fullTitle());

  if (!total) return fn();

  this.emit('suite', this.suite = suite);

  function next() {
    var curr = suite.suites[i++];
    if (!curr) return done();
    self.runSuite(curr, next);
  }

  function done() {
    self.suite = suite;
    self.hook('afterAll', function(){
      self.emit('suite end', suite);
      fn();
    });
  }

  this.hook('beforeAll', function(){
    self.runTests(suite, next);
  });
};

/**
 * Handle uncaught exceptions.
 *
 * @param {Error} err
 * @api private
 */

Runner.prototype.uncaught = function(err){
  debug('uncaught exception %s', err.message);
  var runnable = this.currentRunnable;
  if (!runnable || 'failed' == runnable.state) return;
  runnable.clearTimeout();
  err.uncaught = true;
  this.fail(runnable, err);

  // recover from test
  if ('test' == runnable.type) {
    this.emit('test end', runnable);
    this.hookUp('afterEach', this.next);
    return;
  }

  // bail on hooks
  this.emit('end');
};

/**
 * Run the root suite and invoke `fn(failures)`
 * on completion.
 *
 * @param {Function} fn
 * @return {Runner} for chaining
 * @api public
 */

Runner.prototype.run = function(fn){
  var self = this
    , fn = fn || function(){};

  function uncaught(err){
    self.uncaught(err);
  }

  debug('start');

  // callback
  this.on('end', function(){
    debug('end');
    process.removeListener('uncaughtException', uncaught);
    fn(self.failures);
  });

  // run suites
  this.emit('start');
  this.runSuite(this.suite, function(){
    debug('finished running');
    self.emit('end');
  });

  // uncaught exception
  process.on('uncaughtException', uncaught);

  return this;
};

/**
 * Filter leaks with the given globals flagged as `ok`.
 *
 * @param {Array} ok
 * @param {Array} globals
 * @return {Array}
 * @api private
 */

function filterLeaks(ok, globals) {
  return filter(globals, function(key){
    var matched = filter(ok, function(ok){
      if (~ok.indexOf('*')) return 0 == key.indexOf(ok.split('*')[0]);
      // Opera and IE expose global variables for HTML element IDs (issue #243)
      if (/^mocha-/.test(key)) return true;
      return key == ok;
    });
    return matched.length == 0 && (!global.navigator || 'onerror' !== key);
  });
}

}); // module: runner.js

require.register("suite.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var EventEmitter = require('browser/events').EventEmitter
  , debug = require('browser/debug')('mocha:suite')
  , milliseconds = require('./ms')
  , utils = require('./utils')
  , Hook = require('./hook');

/**
 * Expose `Suite`.
 */

exports = module.exports = Suite;

/**
 * Create a new `Suite` with the given `title`
 * and parent `Suite`. When a suite with the
 * same title is already present, that suite
 * is returned to provide nicer reporter
 * and more flexible meta-testing.
 *
 * @param {Suite} parent
 * @param {String} title
 * @return {Suite}
 * @api public
 */

exports.create = function(parent, title){
  var suite = new Suite(title, parent.ctx);
  suite.parent = parent;
  if (parent.pending) suite.pending = true;
  title = suite.fullTitle();
  parent.addSuite(suite);
  return suite;
};

/**
 * Initialize a new `Suite` with the given
 * `title` and `ctx`.
 *
 * @param {String} title
 * @param {Context} ctx
 * @api private
 */

function Suite(title, ctx) {
  this.title = title;
  this.ctx = ctx;
  this.suites = [];
  this.tests = [];
  this.pending = false;
  this._beforeEach = [];
  this._beforeAll = [];
  this._afterEach = [];
  this._afterAll = [];
  this.root = !title;
  this._timeout = 2000;
  this._slow = 75;
  this._bail = false;
}

/**
 * Inherit from `EventEmitter.prototype`.
 */

function F(){};
F.prototype = EventEmitter.prototype;
Suite.prototype = new F;
Suite.prototype.constructor = Suite;


/**
 * Return a clone of this `Suite`.
 *
 * @return {Suite}
 * @api private
 */

Suite.prototype.clone = function(){
  var suite = new Suite(this.title);
  debug('clone');
  suite.ctx = this.ctx;
  suite.timeout(this.timeout());
  suite.slow(this.slow());
  suite.bail(this.bail());
  return suite;
};

/**
 * Set timeout `ms` or short-hand such as "2s".
 *
 * @param {Number|String} ms
 * @return {Suite|Number} for chaining
 * @api private
 */

Suite.prototype.timeout = function(ms){
  if (0 == arguments.length) return this._timeout;
  if ('string' == typeof ms) ms = milliseconds(ms);
  debug('timeout %d', ms);
  this._timeout = parseInt(ms, 10);
  return this;
};

/**
 * Set slow `ms` or short-hand such as "2s".
 *
 * @param {Number|String} ms
 * @return {Suite|Number} for chaining
 * @api private
 */

Suite.prototype.slow = function(ms){
  if (0 === arguments.length) return this._slow;
  if ('string' == typeof ms) ms = milliseconds(ms);
  debug('slow %d', ms);
  this._slow = ms;
  return this;
};

/**
 * Sets whether to bail after first error.
 *
 * @parma {Boolean} bail
 * @return {Suite|Number} for chaining
 * @api private
 */

Suite.prototype.bail = function(bail){
  if (0 == arguments.length) return this._bail;
  debug('bail %s', bail);
  this._bail = bail;
  return this;
};

/**
 * Run `fn(test[, done])` before running tests.
 *
 * @param {Function} fn
 * @return {Suite} for chaining
 * @api private
 */

Suite.prototype.beforeAll = function(fn){
  if (this.pending) return this;
  var hook = new Hook('"before all" hook', fn);
  hook.parent = this;
  hook.timeout(this.timeout());
  hook.slow(this.slow());
  hook.ctx = this.ctx;
  this._beforeAll.push(hook);
  this.emit('beforeAll', hook);
  return this;
};

/**
 * Run `fn(test[, done])` after running tests.
 *
 * @param {Function} fn
 * @return {Suite} for chaining
 * @api private
 */

Suite.prototype.afterAll = function(fn){
  if (this.pending) return this;
  var hook = new Hook('"after all" hook', fn);
  hook.parent = this;
  hook.timeout(this.timeout());
  hook.slow(this.slow());
  hook.ctx = this.ctx;
  this._afterAll.push(hook);
  this.emit('afterAll', hook);
  return this;
};

/**
 * Run `fn(test[, done])` before each test case.
 *
 * @param {Function} fn
 * @return {Suite} for chaining
 * @api private
 */

Suite.prototype.beforeEach = function(fn){
  if (this.pending) return this;
  var hook = new Hook('"before each" hook', fn);
  hook.parent = this;
  hook.timeout(this.timeout());
  hook.slow(this.slow());
  hook.ctx = this.ctx;
  this._beforeEach.push(hook);
  this.emit('beforeEach', hook);
  return this;
};

/**
 * Run `fn(test[, done])` after each test case.
 *
 * @param {Function} fn
 * @return {Suite} for chaining
 * @api private
 */

Suite.prototype.afterEach = function(fn){
  if (this.pending) return this;
  var hook = new Hook('"after each" hook', fn);
  hook.parent = this;
  hook.timeout(this.timeout());
  hook.slow(this.slow());
  hook.ctx = this.ctx;
  this._afterEach.push(hook);
  this.emit('afterEach', hook);
  return this;
};

/**
 * Add a test `suite`.
 *
 * @param {Suite} suite
 * @return {Suite} for chaining
 * @api private
 */

Suite.prototype.addSuite = function(suite){
  suite.parent = this;
  suite.timeout(this.timeout());
  suite.slow(this.slow());
  suite.bail(this.bail());
  this.suites.push(suite);
  this.emit('suite', suite);
  return this;
};

/**
 * Add a `test` to this suite.
 *
 * @param {Test} test
 * @return {Suite} for chaining
 * @api private
 */

Suite.prototype.addTest = function(test){
  test.parent = this;
  test.timeout(this.timeout());
  test.slow(this.slow());
  test.ctx = this.ctx;
  this.tests.push(test);
  this.emit('test', test);
  return this;
};

/**
 * Return the full title generated by recursively
 * concatenating the parent's full title.
 *
 * @return {String}
 * @api public
 */

Suite.prototype.fullTitle = function(){
  if (this.parent) {
    var full = this.parent.fullTitle();
    if (full) return full + ' ' + this.title;
  }
  return this.title;
};

/**
 * Return the total number of tests.
 *
 * @return {Number}
 * @api public
 */

Suite.prototype.total = function(){
  return utils.reduce(this.suites, function(sum, suite){
    return sum + suite.total();
  }, 0) + this.tests.length;
};

/**
 * Iterates through each suite recursively to find
 * all tests. Applies a function in the format
 * `fn(test)`.
 *
 * @param {Function} fn
 * @return {Suite}
 * @api private
 */

Suite.prototype.eachTest = function(fn){
  utils.forEach(this.tests, fn);
  utils.forEach(this.suites, function(suite){
    suite.eachTest(fn);
  });
  return this;
};

}); // module: suite.js

require.register("test.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var Runnable = require('./runnable');

/**
 * Expose `Test`.
 */

module.exports = Test;

/**
 * Initialize a new `Test` with the given `title` and callback `fn`.
 *
 * @param {String} title
 * @param {Function} fn
 * @api private
 */

function Test(title, fn) {
  Runnable.call(this, title, fn);
  this.pending = !fn;
  this.type = 'test';
}

/**
 * Inherit from `Runnable.prototype`.
 */

function F(){};
F.prototype = Runnable.prototype;
Test.prototype = new F;
Test.prototype.constructor = Test;


}); // module: test.js

require.register("utils.js", function(module, exports, require){

/**
 * Module dependencies.
 */

var fs = require('browser/fs')
  , path = require('browser/path')
  , join = path.join
  , debug = require('browser/debug')('mocha:watch');

/**
 * Ignored directories.
 */

var ignore = ['node_modules', '.git'];

/**
 * Escape special characters in the given string of html.
 *
 * @param  {String} html
 * @return {String}
 * @api private
 */

exports.escape = function(html){
  return String(html)
    .replace(/&/g, '&amp;')
    .replace(/"/g, '&quot;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;');
};

/**
 * Array#forEach (<=IE8)
 *
 * @param {Array} array
 * @param {Function} fn
 * @param {Object} scope
 * @api private
 */

exports.forEach = function(arr, fn, scope){
  for (var i = 0, l = arr.length; i < l; i++)
    fn.call(scope, arr[i], i);
};

/**
 * Array#indexOf (<=IE8)
 *
 * @parma {Array} arr
 * @param {Object} obj to find index of
 * @param {Number} start
 * @api private
 */

exports.indexOf = function(arr, obj, start){
  for (var i = start || 0, l = arr.length; i < l; i++) {
    if (arr[i] === obj)
      return i;
  }
  return -1;
};

/**
 * Array#reduce (<=IE8)
 *
 * @param {Array} array
 * @param {Function} fn
 * @param {Object} initial value
 * @api private
 */

exports.reduce = function(arr, fn, val){
  var rval = val;

  for (var i = 0, l = arr.length; i < l; i++) {
    rval = fn(rval, arr[i], i, arr);
  }

  return rval;
};

/**
 * Array#filter (<=IE8)
 *
 * @param {Array} array
 * @param {Function} fn
 * @api private
 */

exports.filter = function(arr, fn){
  var ret = [];

  for (var i = 0, l = arr.length; i < l; i++) {
    var val = arr[i];
    if (fn(val, i, arr)) ret.push(val);
  }

  return ret;
};

/**
 * Object.keys (<=IE8)
 *
 * @param {Object} obj
 * @return {Array} keys
 * @api private
 */

exports.keys = Object.keys || function(obj) {
  var keys = []
    , has = Object.prototype.hasOwnProperty // for `window` on <=IE8

  for (var key in obj) {
    if (has.call(obj, key)) {
      keys.push(key);
    }
  }

  return keys;
};

/**
 * Watch the given `files` for changes
 * and invoke `fn(file)` on modification.
 *
 * @param {Array} files
 * @param {Function} fn
 * @api private
 */

exports.watch = function(files, fn){
  var options = { interval: 100 };
  files.forEach(function(file){
    debug('file %s', file);
    fs.watchFile(file, options, function(curr, prev){
      if (prev.mtime < curr.mtime) fn(file);
    });
  });
};

/**
 * Ignored files.
 */

function ignored(path){
  return !~ignore.indexOf(path);
}

/**
 * Lookup files in the given `dir`.
 *
 * @return {Array}
 * @api private
 */

exports.files = function(dir, ret){
  ret = ret || [];

  fs.readdirSync(dir)
  .filter(ignored)
  .forEach(function(path){
    path = join(dir, path);
    if (fs.statSync(path).isDirectory()) {
      exports.files(path, ret);
    } else if (path.match(/\.(js|coffee)$/)) {
      ret.push(path);
    }
  });

  return ret;
};

/**
 * Compute a slug from the given `str`.
 *
 * @param {String} str
 * @return {String}
 * @api private
 */

exports.slug = function(str){
  return str
    .toLowerCase()
    .replace(/ +/g, '-')
    .replace(/[^-\w]/g, '');
};

/**
 * Strip the function definition from `str`,
 * and re-indent for pre whitespace.
 */

exports.clean = function(str) {
  str = str
    .replace(/^function *\(.*\) *{/, '')
    .replace(/\s+\}$/, '');

  var spaces = str.match(/^\n?( *)/)[1].length
    , re = new RegExp('^ {' + spaces + '}', 'gm');

  str = str.replace(re, '');

  return exports.trim(str);
};

/**
 * Escape regular expression characters in `str`.
 *
 * @param {String} str
 * @return {String}
 * @api private
 */

exports.escapeRegexp = function(str){
  return str.replace(/[-\\^$*+?.()|[\]{}]/g, "\\$&");
};

/**
 * Trim the given `str`.
 *
 * @param {String} str
 * @return {String}
 * @api private
 */

exports.trim = function(str){
  return str.replace(/^\s+|\s+$/g, '');
};

/**
 * Parse the given `qs`.
 *
 * @param {String} qs
 * @return {Object}
 * @api private
 */

exports.parseQuery = function(qs){
  return exports.reduce(qs.replace('?', '').split('&'), function(obj, pair){
    var i = pair.indexOf('=')
      , key = pair.slice(0, i)
      , val = pair.slice(++i);

    obj[key] = decodeURIComponent(val);
    return obj;
  }, {});
};

/**
 * Highlight the given string of `js`.
 *
 * @param {String} js
 * @return {String}
 * @api private
 */

function highlight(js) {
  return js
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/\/\/(.*)/gm, '<span class="comment">//$1</span>')
    .replace(/('.*?')/gm, '<span class="string">$1</span>')
    .replace(/(\d+\.\d+)/gm, '<span class="number">$1</span>')
    .replace(/(\d+)/gm, '<span class="number">$1</span>')
    .replace(/\bnew *(\w+)/gm, '<span class="keyword">new</span> <span class="init">$1</span>')
    .replace(/\b(function|new|throw|return|var|if|else)\b/gm, '<span class="keyword">$1</span>')
}

/**
 * Highlight the contents of tag `name`.
 *
 * @param {String} name
 * @api private
 */

exports.highlightTags = function(name) {
  var code = document.getElementsByTagName(name);
  for (var i = 0, len = code.length; i < len; ++i) {
    code[i].innerHTML = highlight(code[i].innerHTML);
  }
};

}); // module: utils.js
/**
 * Node shims.
 *
 * These are meant only to allow
 * mocha.js to run untouched, not
 * to allow running node code in
 * the browser.
 */

process = {};
process.exit = function(status){};
process.stdout = {};
global = window;

/**
 * Remove uncaughtException listener.
 */

process.removeListener = function(e){
  if ('uncaughtException' == e) {
    window.onerror = null;
  }
};

/**
 * Implements uncaughtException listener.
 */

process.on = function(e, fn){
  if ('uncaughtException' == e) {
    window.onerror = function(err, url, line){
      fn(new Error(err + ' (' + url + ':' + line + ')'));
    };
  }
};

// boot
;(function(){

  /**
   * Expose mocha.
   */

  var Mocha = window.Mocha = require('mocha'),
      mocha = window.mocha = new Mocha({ reporter: 'html' });

  var immediateQueue = []
    , immediateTimeout;

  function timeslice() {
    var immediateStart = new Date().getTime();
    while (immediateQueue.length && (new Date().getTime() - immediateStart) < 100) {
      immediateQueue.shift()();
    }
    if (immediateQueue.length) {
      immediateTimeout = setTimeout(timeslice, 0);
    } else {
      immediateTimeout = null;
    }
  }

  /**
   * High-performance override of Runner.immediately.
   */

  Mocha.Runner.immediately = function(callback) {
    immediateQueue.push(callback);
    if (!immediateTimeout) {
      immediateTimeout = setTimeout(timeslice, 0);
    }
  };

  /**
   * Override ui to ensure that the ui functions are initialized.
   * Normally this would happen in Mocha.prototype.loadFiles.
   */

  mocha.ui = function(ui){
    Mocha.prototype.ui.call(this, ui);
    this.suite.emit('pre-require', window, null, this);
    return this;
  };

  /**
   * Setup mocha with the given setting options.
   */

  mocha.setup = function(opts){
    if ('string' == typeof opts) opts = { ui: opts };
    for (var opt in opts) this[opt](opts[opt]);
    return this;
  };

  /**
   * Run mocha, returning the Runner.
   */

  mocha.run = function(fn){
    var options = mocha.options;
    mocha.globals('location');

    var query = Mocha.utils.parseQuery(window.location.search || '');
    if (query.grep) mocha.grep(query.grep);
    if (query.invert) mocha.invert();

    return Mocha.prototype.run.call(mocha, function(){
      Mocha.utils.highlightTags('code');
      if (fn) fn();
    });
  };
})();
})();

================================================
FILE: vendors/firmcard/test/sinon.js
================================================
/**
 * Sinon.JS 1.7.1, 2013/05/07
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @author Contributors: https://github.com/cjohansen/Sinon.JS/blob/master/AUTHORS
 *
 * (The BSD License)
 * 
 * Copyright (c) 2010-2013, Christian Johansen, christian@cjohansen.no
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 
 *     * Redistributions of source code must retain the above copyright notice,
 *       this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright notice,
 *       this list of conditions and the following disclaimer in the documentation
 *       and/or other materials provided with the distribution.
 *     * Neither the name of Christian Johansen nor the names of his contributors
 *       may be used to endorse or promote products derived from this software
 *       without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

this.sinon = (function () {
var buster = (function (setTimeout, B) {
    var isNode = typeof require == "function" && typeof module == "object";
    var div = typeof document != "undefined" && document.createElement("div");
    var F = function () {};

    var buster = {
        bind: function bind(obj, methOrProp) {
            var method = typeof methOrProp == "string" ? obj[methOrProp] : methOrProp;
            var args = Array.prototype.slice.call(arguments, 2);
            return function () {
                var allArgs = args.concat(Array.prototype.slice.call(arguments));
                return method.apply(obj, allArgs);
            };
        },

        partial: function partial(fn) {
            var args = [].slice.call(arguments, 1);
            return function () {
                return fn.apply(this, args.concat([].slice.call(arguments)));
            };
        },

        create: function create(object) {
            F.prototype = object;
            return new F();
        },

        extend: function extend(target) {
            if (!target) { return; }
            for (var i = 1, l = arguments.length, prop; i < l; ++i) {
                for (prop in arguments[i]) {
                    target[prop] = arguments[i][prop];
                }
            }
            return target;
        },

        nextTick: function nextTick(callback) {
            if (typeof process != "undefined" && process.nextTick) {
                return process.nextTick(callback);
            }
            setTimeout(callback, 0);
        },

        functionName: function functionName(func) {
            if (!func) return "";
            if (func.displayName) return func.displayName;
            if (func.name) return func.name;
            var matches = func.toString().match(/function\s+([^\(]+)/m);
            return matches && matches[1] || "";
        },

        isNode: function isNode(obj) {
            if (!div) return false;
            try {
                obj.appendChild(div);
                obj.removeChild(div);
            } catch (e) {
                return false;
            }
            return true;
        },

        isElement: function isElement(obj) {
            return obj && obj.nodeType === 1 && buster.isNode(obj);
        },

        isArray: function isArray(arr) {
            return Object.prototype.toString.call(arr) == "[object Array]";
        },

        flatten: function flatten(arr) {
            var result = [], arr = arr || [];
            for (var i = 0, l = arr.length; i < l; ++i) {
                result = result.concat(buster.isArray(arr[i]) ? flatten(arr[i]) : arr[i]);
            }
            return result;
        },

        each: function each(arr, callback) {
            for (var i = 0, l = arr.length; i < l; ++i) {
                callback(arr[i]);
            }
        },

        map: function map(arr, callback) {
            var results = [];
            for (var i = 0, l = arr.length; i < l; ++i) {
                results.push(callback(arr[i]));
            }
            return results;
        },

        parallel: function parallel(fns, callback) {
            function cb(err, res) {
                if (typeof callback == "function") {
                    callback(err, res);
                    callback = null;
                }
            }
            if (fns.length == 0) { return cb(null, []); }
            var remaining = fns.length, results = [];
            function makeDone(num) {
                return function done(err, result) {
                    if (err) { return cb(err); }
                    results[num] = result;
                    if (--remaining == 0) { cb(null, results); }
                };
            }
            for (var i = 0, l = fns.length; i < l; ++i) {
                fns[i](makeDone(i));
            }
        },

        series: function series(fns, callback) {
            function cb(err, res) {
                if (typeof callback == "function") {
                    callback(err, res);
                }
            }
            var remaining = fns.slice();
            var results = [];
            function callNext() {
                if (remaining.length == 0) return cb(null, results);
                var promise = remaining.shift()(next);
                if (promise && typeof promise.then == "function") {
                    promise.then(buster.partial(next, null), next);
                }
            }
            function next(err, result) {
                if (err) return cb(err);
                results.push(result);
                callNext();
            }
            callNext();
        },

        countdown: function countdown(num, done) {
            return function () {
                if (--num == 0) done();
            };
        }
    };

    if (typeof process === "object" &&
        typeof require === "function" && typeof module === "object") {
        var crypto = require("crypto");
        var path = require("path");

        buster.tmpFile = function (fileName) {
            var hashed = crypto.createHash("sha1");
            hashed.update(fileName);
            var tmpfileName = hashed.digest("hex");

            if (process.platform == "win32") {
                return path.join(process.env["TEMP"], tmpfileName);
            } else {
                return path.join("/tmp", tmpfileName);
            }
        };
    }

    if (Array.prototype.some) {
        buster.some = function (arr, fn, thisp) {
            return arr.some(fn, thisp);
        };
    } else {
        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some
        buster.some = function (arr, fun, thisp) {
                        if (arr == null) { throw new TypeError(); }
            arr = Object(arr);
            var len = arr.length >>> 0;
            if (typeof fun !== "function") { throw new TypeError(); }

            for (var i = 0; i < len; i++) {
                if (arr.hasOwnProperty(i) && fun.call(thisp, arr[i], i, arr)) {
                    return true;
                }
            }

            return false;
        };
    }

    if (Array.prototype.filter) {
        buster.filter = function (arr, fn, thisp) {
            return arr.filter(fn, thisp);
        };
    } else {
        // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/filter
        buster.filter = function (fn, thisp) {
                        if (this == null) { throw new TypeError(); }

            var t = Object(this);
            var len = t.length >>> 0;
            if (typeof fn != "function") { throw new TypeError(); }

            var res = [];
            for (var i = 0; i < len; i++) {
                if (i in t) {
                    var val = t[i]; // in case fun mutates this
                    if (fn.call(thisp, val, i, t)) { res.push(val); }
                }
            }

            return res;
        };
    }

    if (isNode) {
        module.exports = buster;
        buster.eventEmitter = require("./buster-event-emitter");
        Object.defineProperty(buster, "defineVersionGetter", {
            get: function () {
                return require("./define-version-getter");
            }
        });
    }

    return buster.extend(B || {}, buster);
}(setTimeout, buster));
if (typeof buster === "undefined") {
    var buster = {};
}

if (typeof module === "object" && typeof require === "function") {
    buster = require("buster-core");
}

buster.format = buster.format || {};
buster.format.excludeConstructors = ["Object", /^.$/];
buster.format.quoteStrings = true;

buster.format.ascii = (function () {
    
    var hasOwn = Object.prototype.hasOwnProperty;

    var specialObjects = [];
    if (typeof global != "undefined") {
        specialObjects.push({ obj: global, value: "[object global]" });
    }
    if (typeof document != "undefined") {
        specialObjects.push({ obj: document, value: "[object HTMLDocument]" });
    }
    if (typeof window != "undefined") {
        specialObjects.push({ obj: window, value: "[object Window]" });
    }

    function keys(object) {
        var k = Object.keys && Object.keys(object) || [];

        if (k.length == 0) {
            for (var prop in object) {
                if (hasOwn.call(object, prop)) {
                    k.push(prop);
                }
            }
        }

        return k.sort();
    }

    function isCircular(object, objects) {
        if (typeof object != "object") {
            return false;
        }

        for (var i = 0, l = objects.length; i < l; ++i) {
            if (objects[i] === object) {
                return true;
            }
        }

        return false;
    }

    function ascii(object, processed, indent) {
        if (typeof object == "string") {
            var quote = typeof this.quoteStrings != "boolean" || this.quoteStrings;
            return processed || quote ? '"' + object + '"' : object;
        }

        if (typeof object == "function" && !(object instanceof RegExp)) {
            return ascii.func(object);
        }

        processed = processed || [];

        if (isCircular(object, processed)) {
            return "[Circular]";
        }

        if (Object.prototype.toString.call(object) == "[object Array]") {
            return ascii.array.call(this, object, processed);
        }

        if (!object) {
            return "" + object;
        }

        if (buster.isElement(object)) {
            return ascii.element(object);
        }

        if (typeof object.toString == "function" &&
            object.toString !== Object.prototype.toString) {
            return object.toString();
        }

        for (var i = 0, l = specialObjects.length; i < l; i++) {
            if (object === specialObjects[i].obj) {
                return specialObjects[i].value;
            }
        }

        return ascii.object.call(this, object, processed, indent);
    }

    ascii.func = function (func) {
        return "function " + buster.functionName(func) + "() {}";
    };

    ascii.array = function (array, processed) {
        processed = processed || [];
        processed.push(array);
        var pieces = [];

        for (var i = 0, l = array.length; i < l; ++i) {
            pieces.push(ascii.call(this, array[i], processed));
        }

        return "[" + pieces.join(", ") + "]";
    };

    ascii.object = function (object, processed, indent) {
        processed = processed || [];
        processed.push(object);
        indent = indent || 0;
        var pieces = [], properties = keys(object), prop, str, obj;
        var is = "";
        var length = 3;

        for (var i = 0, l = indent; i < l; ++i) {
            is += " ";
        }

        for (i = 0, l = properties.length; i < l; ++i) {
            prop = properties[i];
            obj = object[prop];

            if (isCircular(obj, processed)) {
                str = "[Circular]";
            } else {
                str = ascii.call(this, obj, processed, indent + 2);
            }

            str = (/\s/.test(prop) ? '"' + prop + '"' : prop) + ": " + str;
            length += str.length;
            pieces.push(str);
        }

        var cons = ascii.constructorName.call(this, object);
        var prefix = cons ? "[" + cons + "] " : ""

        return (length + indent) > 80 ?
            prefix + "{\n  " + is + pieces.join(",\n  " + is) + "\n" + is + "}" :
            prefix + "{ " + pieces.join(", ") + " }";
    };

    ascii.element = function (element) {
        var tagName = element.tagName.toLowerCase();
        var attrs = element.attributes, attribute, pairs = [], attrName;

        for (var i = 0, l = attrs.length; i < l; ++i) {
            attribute = attrs.item(i);
            attrName = attribute.nodeName.toLowerCase().replace("html:", "");

            if (attrName == "contenteditable" && attribute.nodeValue == "inherit") {
                continue;
            }

            if (!!attribute.nodeValue) {
                pairs.push(attrName + "=\"" + attribute.nodeValue + "\"");
            }
        }

        var formatted = "<" + tagName + (pairs.length > 0 ? " " : "");
        var content = element.innerHTML;

        if (content.length > 20) {
            content = content.substr(0, 20) + "[...]";
        }

        var res = formatted + pairs.join(" ") + ">" + content + "</" + tagName + ">";

        return res.replace(/ contentEditable="inherit"/, "");
    };

    ascii.constructorName = function (object) {
        var name = buster.functionName(object && object.constructor);
        var excludes = this.excludeConstructors || buster.format.excludeConstructors || [];

        for (var i = 0, l = excludes.length; i < l; ++i) {
            if (typeof excludes[i] == "string" && excludes[i] == name) {
                return "";
            } else if (excludes[i].test && excludes[i].test(name)) {
                return "";
            }
        }

        return name;
    };

    return ascii;
}());

if (typeof module != "undefined") {
    module.exports = buster.format;
}
/*jslint eqeqeq: false, onevar: false, forin: true, nomen: false, regexp: false, plusplus: false*/
/*global module, require, __dirname, document*/
/**
 * Sinon core utilities. For internal use only.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

var sinon = (function (buster) {
    var div = typeof document != "undefined" && document.createElement("div");
    var hasOwn = Object.prototype.hasOwnProperty;

    function isDOMNode(obj) {
        var success = false;

        try {
            obj.appendChild(div);
            success = div.parentNode == obj;
        } catch (e) {
            return false;
        } finally {
            try {
                obj.removeChild(div);
            } catch (e) {
                // Remove failed, not much we can do about that
            }
        }

        return success;
    }

    function isElement(obj) {
        return div && obj && obj.nodeType === 1 && isDOMNode(obj);
    }

    function isFunction(obj) {
        return typeof obj === "function" || !!(obj && obj.constructor && obj.call && obj.apply);
    }

    function mirrorProperties(target, source) {
        for (var prop in source) {
            if (!hasOwn.call(target, prop)) {
                target[prop] = source[prop];
            }
        }
    }

    function isRestorable (obj) {
        return typeof obj === "function" && typeof obj.restore === "function" && obj.restore.sinon;
    }

    var sinon = {
        wrapMethod: function wrapMethod(object, property, method) {
            if (!object) {
                throw new TypeError("Should wrap property of object");
            }

            if (typeof method != "function") {
                throw new TypeError("Method wrapper should be function");
            }

            var wrappedMethod = object[property];

            if (!isFunction(wrappedMethod)) {
                throw new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " +
                                    property + " as function");
            }

            if (wrappedMethod.restore && wrappedMethod.restore.sinon) {
                throw new TypeError("Attempted to wrap " + property + " which is already wrapped");
            }

            if (wrappedMethod.calledBefore) {
                var verb = !!wrappedMethod.returns ? "stubbed" : "spied on";
                throw new TypeError("Attempted to wrap " + property + " which is already " + verb);
            }

            // IE 8 does not support hasOwnProperty on the window object.
            var owned = hasOwn.call(object, property);
            object[property] = method;
            method.displayName = property;

            method.restore = function () {
                // For prototype properties try to reset by delete first.
                // If this fails (ex: localStorage on mobile safari) then force a reset
                // via direct assignment.
                if (!owned) {
                    delete object[property];
                }
                if (object[property] === method) {
                    object[property] = wrappedMethod;
                }
            };

            method.restore.sinon = true;
            mirrorProperties(method, wrappedMethod);

            return method;
        },

        extend: function extend(target) {
            for (var i = 1, l = arguments.length; i < l; i += 1) {
                for (var prop in arguments[i]) {
                    if (arguments[i].hasOwnProperty(prop)) {
                        target[prop] = arguments[i][prop];
                    }

                    // DONT ENUM bug, only care about toString
                    if (arguments[i].hasOwnProperty("toString") &&
                        arguments[i].toString != target.toString) {
                        target.toString = arguments[i].toString;
                    }
                }
            }

            return target;
        },

        create: function create(proto) {
            var F = function () {};
            F.prototype = proto;
            return new F();
        },

        deepEqual: function deepEqual(a, b) {
            if (sinon.match && sinon.match.isMatcher(a)) {
                return a.test(b);
            }
            if (typeof a != "object" || typeof b != "object") {
                return a === b;
            }

            if (isElement(a) || isElement(b)) {
                return a === b;
            }

            if (a === b) {
                return true;
            }

            if ((a === null && b !== null) || (a !== null && b === null)) {
                return false;
            }

            var aString = Object.prototype.toString.call(a);
            if (aString != Object.prototype.toString.call(b)) {
                return false;
            }

            if (aString == "[object Array]") {
                if (a.length !== b.length) {
                    return false;
                }

                for (var i = 0, l = a.length; i < l; i += 1) {
                    if (!deepEqual(a[i], b[i])) {
                        return false;
                    }
                }

                return true;
            }

            var prop, aLength = 0, bLength = 0;

            for (prop in a) {
                aLength += 1;

                if (!deepEqual(a[prop], b[prop])) {
                    return false;
                }
            }

            for (prop in b) {
                bLength += 1;
            }

            return aLength == bLength;
        },

        functionName: function functionName(func) {
            var name = func.displayName || func.name;

            // Use function decomposition as a last resort to get function
            // name. Does not rely on function decomposition to work - if it
            // doesn't debugging will be slightly less informative
            // (i.e. toString will say 'spy' rather than 'myFunc').
            if (!name) {
                var matches = func.toString().match(/function ([^\s\(]+)/);
                name = matches && matches[1];
            }

            return name;
        },

        functionToString: function toString() {
            if (this.getCall && this.callCount) {
                var thisValue, prop, i = this.callCount;

                while (i--) {
                    thisValue = this.getCall(i).thisValue;

                    for (prop in thisValue) {
                        if (thisValue[prop] === this) {
                            return prop;
                        }
                    }
                }
            }

            return this.displayName || "sinon fake";
        },

        getConfig: function (custom) {
            var config = {};
            custom = custom || {};
            var defaults = sinon.defaultConfig;

            for (var prop in defaults) {
                if (defaults.hasOwnProperty(prop)) {
                    config[prop] = custom.hasOwnProperty(prop) ? custom[prop] : defaults[prop];
                }
            }

            return config;
        },

        format: function (val) {
            return "" + val;
        },

        defaultConfig: {
            injectIntoThis: true,
            injectInto: null,
            properties: ["spy", "stub", "mock", "clock", "server", "requests"],
            useFakeTimers: true,
            useFakeServer: true
        },

        timesInWords: function timesInWords(count) {
            return count == 1 && "once" ||
                count == 2 && "twice" ||
                count == 3 && "thrice" ||
                (count || 0) + " times";
        },

        calledInOrder: function (spies) {
            for (var i = 1, l = spies.length; i < l; i++) {
                if (!spies[i - 1].calledBefore(spies[i]) || !spies[i].called) {
                    return false;
                }
            }

            return true;
        },

        orderByFirstCall: function (spies) {
            return spies.sort(function (a, b) {
                // uuid, won't ever be equal
                var aCall = a.getCall(0);
                var bCall = b.getCall(0);
                var aId = aCall && aCall.callId || -1;
                var bId = bCall && bCall.callId || -1;

                return aId < bId ? -1 : 1;
            });
        },

        log: function () {},

        logError: function (label, err) {
            var msg = label + " threw exception: "
            sinon.log(msg + "[" + err.name + "] " + err.message);
            if (err.stack) { sinon.log(err.stack); }

            setTimeout(function () {
                err.message = msg + err.message;
                throw err;
            }, 0);
        },

        typeOf: function (value) {
            if (value === null) {
                return "null";
            }
            else if (value === undefined) {
                return "undefined";
            }
            var string = Object.prototype.toString.call(value);
            return string.substring(8, string.length - 1).toLowerCase();
        },

        createStubInstance: function (constructor) {
            if (typeof constructor !== "function") {
                throw new TypeError("The constructor should be a function.");
            }
            return sinon.stub(sinon.create(constructor.prototype));
        },

        restore: function (object) {
            if (object !== null && typeof object === "object") {
                for (var prop in object) {
                    if (isRestorable(object[prop])) {
                        object[prop].restore();
                    }
                }
            }
            else if (isRestorable(object)) {
                object.restore();
            }
        }
    };

    var isNode = typeof module == "object" && typeof require == "function";

    if (isNode) {
        try {
            buster = { format: require("buster-format") };
        } catch (e) {}
        module.exports = sinon;
        module.exports.spy = require("./sinon/spy");
        module.exports.spyCall = require("./sinon/call");
        module.exports.stub = require("./sinon/stub");
        module.exports.mock = require("./sinon/mock");
        module.exports.collection = require("./sinon/collection");
        module.exports.assert = require("./sinon/assert");
        module.exports.sandbox = require("./sinon/sandbox");
        module.exports.test = require("./sinon/test");
        module.exports.testCase = require("./sinon/test_case");
        module.exports.assert = require("./sinon/assert");
        module.exports.match = require("./sinon/match");
    }

    if (buster) {
        var formatter = sinon.create(buster.format);
        formatter.quoteStrings = false;
        sinon.format = function () {
            return formatter.ascii.apply(formatter, arguments);
        };
    } else if (isNode) {
        try {
            var util = require("util");
            sinon.format = function (value) {
                return typeof value == "object" && value.toString === Object.prototype.toString ? util.inspect(value) : value;
            };
        } catch (e) {
            /* Node, but no util module - would be very old, but better safe than
             sorry */
        }
    }

    return sinon;
}(typeof buster == "object" && buster));

/* @depend ../sinon.js */
/*jslint eqeqeq: false, onevar: false, plusplus: false*/
/*global module, require, sinon*/
/**
 * Match functions
 *
 * @author Maximilian Antoni (mail@maxantoni.de)
 * @license BSD
 *
 * Copyright (c) 2012 Maximilian Antoni
 */

(function (sinon) {
    var commonJSModule = typeof module == "object" && typeof require == "function";

    if (!sinon && commonJSModule) {
        sinon = require("../sinon");
    }

    if (!sinon) {
        return;
    }

    function assertType(value, type, name) {
        var actual = sinon.typeOf(value);
        if (actual !== type) {
            throw new TypeError("Expected type of " + name + " to be " +
                type + ", but was " + actual);
        }
    }

    var matcher = {
        toString: function () {
            return this.message;
        }
    };

    function isMatcher(object) {
        return matcher.isPrototypeOf(object);
    }

    function matchObject(expectation, actual) {
        if (actual === null || actual === undefined) {
            return false;
        }
        for (var key in expectation) {
            if (expectation.hasOwnProperty(key)) {
                var exp = expectation[key];
                var act = actual[key];
                if (match.isMatcher(exp)) {
                    if (!exp.test(act)) {
                        return false;
                    }
                } else if (sinon.typeOf(exp) === "object") {
                    if (!matchObject(exp, act)) {
                        return false;
                    }
                } else if (!sinon.deepEqual(exp, act)) {
                    return false;
                }
            }
        }
        return true;
    }

    matcher.or = function (m2) {
        if (!isMatcher(m2)) {
            throw new TypeError("Matcher expected");
        }
        var m1 = this;
        var or = sinon.create(matcher);
        or.test = function (actual) {
            return m1.test(actual) || m2.test(actual);
        };
        or.message = m1.message + ".or(" + m2.message + ")";
        return or;
    };

    matcher.and = function (m2) {
        if (!isMatcher(m2)) {
            throw new TypeError("Matcher expected");
        }
        var m1 = this;
        var and = sinon.create(matcher);
        and.test = function (actual) {
            return m1.test(actual) && m2.test(actual);
        };
        and.message = m1.message + ".and(" + m2.message + ")";
        return and;
    };

    var match = function (expectation, message) {
        var m = sinon.create(matcher);
        var type = sinon.typeOf(expectation);
        switch (type) {
        case "object":
            if (typeof expectation.test === "function") {
                m.test = function (actual) {
                    return expectation.test(actual) === true;
                };
                m.message = "match(" + sinon.functionName(expectation.test) + ")";
                return m;
            }
            var str = [];
            for (var key in expectation) {
                if (expectation.hasOwnProperty(key)) {
                    str.push(key + ": " + expectation[key]);
                }
            }
            m.test = function (actual) {
                return matchObject(expectation, actual);
            };
            m.message = "match(" + str.join(", ") + ")";
            break;
        case "number":
            m.test = function (actual) {
                return expectation == actual;
            };
            break;
        case "string":
            m.test = function (actual) {
                if (typeof actual !== "string") {
                    return false;
                }
                return actual.indexOf(expectation) !== -1;
            };
            m.message = "match(\"" + expectation + "\")";
            break;
        case "regexp":
            m.test = function (actual) {
                if (typeof actual !== "string") {
                    return false;
                }
                return expectation.test(actual);
            };
            break;
        case "function":
            m.test = expectation;
            if (message) {
                m.message = message;
            } else {
                m.message = "match(" + sinon.functionName(expectation) + ")";
            }
            break;
        default:
            m.test = function (actual) {
              return sinon.deepEqual(expectation, actual);
            };
        }
        if (!m.message) {
            m.message = "match(" + expectation + ")";
        }
        return m;
    };

    match.isMatcher = isMatcher;

    match.any = match(function () {
        return true;
    }, "any");

    match.defined = match(function (actual) {
        return actual !== null && actual !== undefined;
    }, "defined");

    match.truthy = match(function (actual) {
        return !!actual;
    }, "truthy");

    match.falsy = match(function (actual) {
        return !actual;
    }, "falsy");

    match.same = function (expectation) {
        return match(function (actual) {
            return expectation === actual;
        }, "same(" + expectation + ")");
    };

    match.typeOf = function (type) {
        assertType(type, "string", "type");
        return match(function (actual) {
            return sinon.typeOf(actual) === type;
        }, "typeOf(\"" + type + "\")");
    };

    match.instanceOf = function (type) {
        assertType(type, "function", "type");
        return match(function (actual) {
            return actual instanceof type;
        }, "instanceOf(" + sinon.functionName(type) + ")");
    };

    function createPropertyMatcher(propertyTest, messagePrefix) {
        return function (property, value) {
            assertType(property, "string", "property");
            var onlyProperty = arguments.length === 1;
            var message = messagePrefix + "(\"" + property + "\"";
            if (!onlyProperty) {
                message += ", " + value;
            }
            message += ")";
            return match(function (actual) {
                if (actual === undefined || actual === null ||
                        !propertyTest(actual, property)) {
                    return false;
                }
                return onlyProperty || sinon.deepEqual(value, actual[property]);
            }, message);
        };
    }

    match.has = createPropertyMatcher(function (actual, property) {
        if (typeof actual === "object") {
            return property in actual;
        }
        return actual[property] !== undefined;
    }, "has");

    match.hasOwn = createPropertyMatcher(function (actual, property) {
        return actual.hasOwnProperty(property);
    }, "hasOwn");

    match.bool = match.typeOf("boolean");
    match.number = match.typeOf("number");
    match.string = match.typeOf("string");
    match.object = match.typeOf("object");
    match.func = match.typeOf("function");
    match.array = match.typeOf("array");
    match.regexp = match.typeOf("regexp");
    match.date = match.typeOf("date");

    if (commonJSModule) {
        module.exports = match;
    } else {
        sinon.match = match;
    }
}(typeof sinon == "object" && sinon || null));

/**
  * @depend ../sinon.js
  * @depend match.js
  */
/*jslint eqeqeq: false, onevar: false, plusplus: false*/
/*global module, require, sinon*/
/**
  * Spy calls
  *
  * @author Christian Johansen (christian@cjohansen.no)
  * @author Maximilian Antoni (mail@maxantoni.de)
  * @license BSD
  *
  * Copyright (c) 2010-2013 Christian Johansen
  * Copyright (c) 2013 Maximilian Antoni
  */

(function (sinon) {
    var commonJSModule = typeof module == "object" && typeof require == "function";
    if (!sinon && commonJSModule) {
        sinon = require("../sinon");
    }

    if (!sinon) {
        return;
    }

    function throwYieldError(proxy, text, args) {
        var msg = sinon.functionName(proxy) + text;
        if (args.length) {
            msg += " Received [" + slice.call(args).join(", ") + "]";
        }
        throw new Error(msg);
    }

    var slice = Array.prototype.slice;

    var callProto = {
        calledOn: function calledOn(thisValue) {
            if (sinon.match && sinon.match.isMatcher(thisValue)) {
                return thisValue.test(this.thisValue);
            }
            return this.thisValue === thisValue;
        },

        calledWith: function calledWith() {
            for (var i = 0, l = arguments.length; i < l; i += 1) {
                if (!sinon.deepEqual(arguments[i], this.args[i])) {
                    return false;
                }
            }

            return true;
        },

        calledWithMatch: function calledWithMatch() {
            for (var i = 0, l = arguments.length; i < l; i += 1) {
                var actual = this.args[i];
                var expectation = arguments[i];
                if (!sinon.match || !sinon.match(expectation).test(actual)) {
                    return false;
                }
            }
            return true;
        },

        calledWithExactly: function calledWithExactly() {
            return arguments.length == this.args.length &&
                this.calledWith.apply(this, arguments);
        },

        notCalledWith: function notCalledWith() {
            return !this.calledWith.apply(this, arguments);
        },

        notCalledWithMatch: function notCalledWithMatch() {
            return !this.calledWithMatch.apply(this, arguments);
        },

        returned: function returned(value) {
            return sinon.deepEqual(value, this.returnValue);
        },

        threw: function threw(error) {
            if (typeof error === "undefined" || !this.exception) {
                return !!this.exception;
            }

            return this.exception === error || this.exception.name === error;
        },

        calledWithNew: function calledWithNew(thisValue) {
            return this.thisValue instanceof this.proxy;
        },

        calledBefore: function (other) {
            return this.callId < other.callId;
        },

        calledAfter: function (other) {
            return this.callId > other.callId;
        },

        callArg: function (pos) {
            this.args[pos]();
        },

        callArgOn: function (pos, thisValue) {
            this.args[pos].apply(thisValue);
        },

        callArgWith: function (pos) {
            this.callArgOnWith.apply(this, [pos, null].concat(slice.call(arguments, 1)));
        },

        callArgOnWith: function (pos, thisValue) {
            var args = slice.call(arguments, 2);
            this.args[pos].apply(thisValue, args);
        },

        "yield": function () {
            this.yieldOn.apply(this, [null].concat(slice.call(arguments, 0)));
        },

        yieldOn: function (thisValue) {
            var args = this.args;
            for (var i = 0, l = args.length; i < l; ++i) {
                if (typeof args[i] === "function") {
                    args[i].apply(thisValue, slice.call(arguments, 1));
                    return;
                }
            }
            throwYieldError(this.proxy, " cannot yield since no callback was passed.", args);
        },

        yieldTo: function (prop) {
            this.yieldToOn.apply(this, [prop, null].concat(slice.call(arguments, 1)));
        },

        yieldToOn: function (prop, thisValue) {
            var args = this.args;
            for (var i = 0, l = args.length; i < l; ++i) {
                if (args[i] && typeof args[i][prop] === "function") {
                    args[i][prop].apply(thisValue, slice.call(arguments, 2));
                    return;
                }
            }
            throwYieldError(this.proxy, " cannot yield to '" + prop +
                "' since no callback was passed.", args);
        },

        toString: function () {
            var callStr = this.proxy.toString() + "(";
            var args = [];

            for (var i = 0, l = this.args.length; i < l; ++i) {
                args.push(sinon.format(this.args[i]));
            }

            callStr = callStr + args.join(", ") + ")";

            if (typeof this.returnValue != "undefined") {
                callStr += " => " + sinon.format(this.returnValue);
            }

            if (this.exception) {
                callStr += " !" + this.exception.name;

                if (this.exception.message) {
                    callStr += "(" + this.exception.message + ")";
                }
            }

            return callStr;
        }
    };

    callProto.invokeCallback = callProto.yield;

    function createSpyCall(spy, thisValue, args, returnValue, exception, id) {
        if (typeof id !== "number") {
            throw new TypeError("Call id is not a number");
        }
        var proxyCall = sinon.create(callProto);
        proxyCall.proxy = spy;
        proxyCall.thisValue = thisValue;
        proxyCall.args = args;
        proxyCall.returnValue = returnValue;
        proxyCall.exception = exception;
        proxyCall.callId = id;

        return proxyCall;
    };
    createSpyCall.toString = callProto.toString; // used by mocks

    if (commonJSModule) {
        module.exports = createSpyCall;
    } else {
        sinon.spyCall = createSpyCall;
    }
}(typeof sinon == "object" && sinon || null));


/**
  * @depend ../sinon.js
  * @depend call.js
  */
/*jslint eqeqeq: false, onevar: false, plusplus: false*/
/*global module, require, sinon*/
/**
  * Spy functions
  *
  * @author Christian Johansen (christian@cjohansen.no)
  * @license BSD
  *
  * Copyright (c) 2010-2013 Christian Johansen
  */

(function (sinon) {
    var commonJSModule = typeof module == "object" && typeof require == "function";
    var push = Array.prototype.push;
    var slice = Array.prototype.slice;
    var callId = 0;

    if (!sinon && commonJSModule) {
        sinon = require("../sinon");
    }

    if (!sinon) {
        return;
    }

    function spy(object, property) {
        if (!property && typeof object == "function") {
            return spy.create(object);
        }

        if (!object && !property) {
            return spy.create(function () { });
        }

        var method = object[property];
        return sinon.wrapMethod(object, property, spy.create(method));
    }

    function matchingFake(fakes, args, strict) {
        if (!fakes) {
            return;
        }

        var alen = args.length;

        for (var i = 0, l = fakes.length; i < l; i++) {
            if (fakes[i].matches(args, strict)) {
                return fakes[i];
            }
        }
    }

    function incrementCallCount() {
        this.called = true;
        this.callCount += 1;
        this.notCalled = false;
        this.calledOnce = this.callCount == 1;
        this.calledTwice = this.callCount == 2;
        this.calledThrice = this.callCount == 3;
    }

    function createCallProperties() {
        this.firstCall = this.getCall(0);
        this.secondCall = this.getCall(1);
        this.thirdCall = this.getCall(2);
        this.lastCall = this.getCall(this.callCount - 1);
    }

    var vars = "a,b,c,d,e,f,g,h,i,j,k,l";
    function createProxy(func) {
        // Retain the function length:
        var p;
        if (func.length) {
            eval("p = (function proxy(" + vars.substring(0, func.length * 2 - 1) +
                ") { return p.invoke(func, this, slice.call(arguments)); });");
        }
        else {
            p = function proxy() {
                return p.invoke(func, this, slice.call(arguments));
            };
        }
        return p;
    }

    var uuid = 0;

    // Public API
    var spyApi = {
        reset: function () {
            this.called = false;
            this.notCalled = true;
            this.calledOnce = false;
            this.calledTwice = false;
            this.calledThrice = false;
            this.callCount = 0;
            this.firstCall = null;
            this.secondCall = null;
            this.thirdCall = null;
            this.lastCall = null;
            this.args = [];
            this.returnValues = [];
            this.thisValues = [];
            this.exceptions = [];
            this.callIds = [];
            if (this.fakes) {
                for (var i = 0; i < this.fakes.length; i++) {
                    this.fakes[i].reset();
                }
            }
        },

        create: function create(func) {
            var name;

            if (typeof func != "function") {
                func = function () { };
            } else {
                name = sinon.functionName(func);
            }

            var proxy = createProxy(func);

            sinon.extend(proxy, spy);
            delete proxy.create;
            sinon.extend(proxy, func);

            proxy.reset();
            proxy.prototype = func.prototype;
            proxy.displayName = name || "spy";
            proxy.toString = sinon.functionToString;
            proxy._create = sinon.spy.create;
            proxy.id = "spy#" + uuid++;

            return proxy;
        },

        invoke: function invoke(func, thisValue, args) {
            var matching = matchingFake(this.fakes, args);
            var exception, returnValue;

            incrementCallCount.call(this);
            push.call(this.thisValues, thisValue);
            push.call(this.args, args);
            push.call(this.callIds, callId++);

            try {
                if (matching) {
                    returnValue = matching.invoke(func, thisValue, args);
                } else {
                    returnValue = (this.func || func).apply(thisValue, args);
                }
            } catch (e) {
                push.call(this.returnValues, undefined);
                exception = e;
                throw e;
            } finally {
                push.call(this.exceptions, exception);
            }

            push.call(this.returnValues, returnValue);

            createCallProperties.call(this);

            return returnValue;
        },

        getCall: function getCall(i) {
            if (i < 0 || i >= this.callCount) {
                return null;
            }

            return sinon.spyCall(this, this.thisValues[i], this.args[i],
                                    this.returnValues[i], this.exceptions[i],
                                    this.callIds[i]);
        },

        calledBefore: function calledBefore(spyFn) {
            if (!this.called) {
                return false;
            }

            if (!spyFn.called) {
                return true;
            }

            return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1];
        },

        calledAfter: function calledAfter(spyFn) {
            if (!this.called || !spyFn.called) {
                return false;
            }

            return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];
        },

        withArgs: function () {
            var args = slice.call(arguments);

            if (this.fakes) {
                var match = matchingFake(this.fakes, args, true);

                if (match) {
                    return match;
                }
            } else {
                this.fakes = [];
            }

            var original = this;
            var fake = this._create();
            fake.matchingAguments = args;
            push.call(this.fakes, fake);

            fake.withArgs = function () {
                return original.withArgs.apply(original, arguments);
            };

            for (var i = 0; i < this.args.length; i++) {
                if (fake.matches(this.args[i])) {
                    incrementCallCount.call(fake);
                    push.call(fake.thisValues, this.thisValues[i]);
                    push.call(fake.args, this.args[i]);
                    push.call(fake.returnValues, this.returnValues[i]);
                    push.call(fake.exceptions, this.exceptions[i]);
                    push.call(fake.callIds, this.callIds[i]);
                }
            }
            createCallProperties.call(fake);

            return fake;
        },

        matches: function (args, strict) {
            var margs = this.matchingAguments;

            if (margs.length <= args.length &&
                sinon.deepEqual(margs, args.slice(0, margs.length))) {
                return !strict || margs.length == args.length;
            }
        },

        printf: function (format) {
            var spy = this;
            var args = slice.call(arguments, 1);
            var formatter;

            return (format || "").replace(/%(.)/g, function (match, specifyer) {
                formatter = spyApi.formatters[specifyer];

                if (typeof formatter == "function") {
                    return formatter.call(null, spy, args);
                } else if (!isNaN(parseInt(specifyer), 10)) {
                    return sinon.format(args[specifyer - 1]);
                }

                return "%" + specifyer;
            });
        }
    };

    function delegateToCalls(method, matchAny, actual, notCalled) {
        spyApi[method] = function () {
            if (!this.called) {
                if (notCalled) {
                    return notCalled.apply(this, arguments);
                }
                return false;
            }

            var currentCall;
            var matches = 0;

            for (var i = 0, l = this.callCount; i < l; i += 1) {
                currentCall = this.getCall(i);

                if (currentCall[actual || method].apply(currentCall, arguments)) {
                    matches += 1;

                    if (matchAny) {
                        return true;
                    }
                }
            }

            return matches === this.callCount;
        };
    }

    delegateToCalls("calledOn", true);
    delegateToCalls("alwaysCalledOn", false, "calledOn");
    delegateToCalls("calledWith", true);
    delegateToCalls("calledWithMatch", true);
    delegateToCalls("alwaysCalledWith", false, "calledWith");
    delegateToCalls("alwaysCalledWithMatch", false, "calledWithMatch");
    delegateToCalls("calledWithExactly", true);
    delegateToCalls("alwaysCalledWithExactly", false, "calledWithExactly");
    delegateToCalls("neverCalledWith", false, "notCalledWith",
        function () { return true; });
    delegateToCalls("neverCalledWithMatch", false, "notCalledWithMatch",
        function () { return true; });
    delegateToCalls("threw", true);
    delegateToCalls("alwaysThrew", false, "threw");
    delegateToCalls("returned", true);
    delegateToCalls("alwaysReturned", false, "returned");
    delegateToCalls("calledWithNew", true);
    delegateToCalls("alwaysCalledWithNew", false, "calledWithNew");
    delegateToCalls("callArg", false, "callArgWith", function () {
        throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
    });
    spyApi.callArgWith = spyApi.callArg;
    delegateToCalls("callArgOn", false, "callArgOnWith", function () {
        throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
    });
    spyApi.callArgOnWith = spyApi.callArgOn;
    delegateToCalls("yield", false, "yield", function () {
        throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
    });
    // "invokeCallback" is an alias for "yield" since "yield" is invalid in strict mode.
    spyApi.invokeCallback = spyApi.yield;
    delegateToCalls("yieldOn", false, "yieldOn", function () {
        throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
    });
    delegateToCalls("yieldTo", false, "yieldTo", function (property) {
        throw new Error(this.toString() + " cannot yield to '" + property +
            "' since it was not yet invoked.");
    });
    delegateToCalls("yieldToOn", false, "yieldToOn", function (property) {
        throw new Error(this.toString() + " cannot yield to '" + property +
            "' since it was not yet invoked.");
    });

    spyApi.formatters = {
        "c": function (spy) {
            return sinon.timesInWords(spy.callCount);
        },

        "n": function (spy) {
            return spy.toString();
        },

        "C": function (spy) {
            var calls = [];

            for (var i = 0, l = spy.callCount; i < l; ++i) {
                var stringifiedCall = "    " + spy.getCall(i).toString();
                if (/\n/.test(calls[i - 1])) {
                    stringifiedCall = "\n" + stringifiedCall;
                }
                push.call(calls, stringifiedCall);
            }

            return calls.length > 0 ? "\n" + calls.join("\n") : "";
        },

        "t": function (spy) {
            var objects = [];

            for (var i = 0, l = spy.callCount; i < l; ++i) {
                push.call(objects, sinon.format(spy.thisValues[i]));
            }

            return objects.join(", ");
        },

        "*": function (spy, args) {
            var formatted = [];

            for (var i = 0, l = args.length; i < l; ++i) {
                push.call(formatted, sinon.format(args[i]));
            }

            return formatted.join(", ");
        }
    };

    sinon.extend(spy, spyApi);

    spy.spyCall = sinon.spyCall;

    if (commonJSModule) {
        module.exports = spy;
    } else {
        sinon.spy = spy;
    }
}(typeof sinon == "object" && sinon || null));

/**
 * @depend ../sinon.js
 * @depend spy.js
 */
/*jslint eqeqeq: false, onevar: false*/
/*global module, require, sinon*/
/**
 * Stub functions
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

(function (sinon) {
    var commonJSModule = typeof module == "object" && typeof require == "function";

    if (!sinon && commonJSModule) {
        sinon = require("../sinon");
    }

    if (!sinon) {
        return;
    }

    function stub(object, property, func) {
        if (!!func && typeof func != "function") {
            throw new TypeError("Custom stub should be function");
        }

        var wrapper;

        if (func) {
            wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;
        } else {
            wrapper = stub.create();
        }

        if (!object && !property) {
            return sinon.stub.create();
        }

        if (!property && !!object && typeof object == "object") {
            for (var prop in object) {
                if (typeof object[prop] === "function") {
                    stub(object, prop);
                }
            }

            return object;
        }

        return sinon.wrapMethod(object, property, wrapper);
    }

    function getChangingValue(stub, property) {
        var index = stub.callCount - 1;
        var values = stub[property];
        var prop = index in values ? values[index] : values[values.length - 1];
        stub[property + "Last"] = prop;

        return prop;
    }

    function getCallback(stub, args) {
        var callArgAt = getChangingValue(stub, "callArgAts");

        if (callArgAt < 0) {
            var callArgProp = getChangingValue(stub, "callArgProps");

            for (var i = 0, l = args.length; i < l; ++i) {
                if (!callArgProp && typeof args[i] == "function") {
                    return args[i];
                }

                if (callArgProp && args[i] &&
                    typeof args[i][callArgProp] == "function") {
                    return args[i][callArgProp];
                }
            }

            return null;
        }

        return args[callArgAt];
    }

    var join = Array.prototype.join;

    function getCallbackError(stub, func, args) {
        if (stub.callArgAtsLast < 0) {
            var msg;

            if (stub.callArgPropsLast) {
                msg = sinon.functionName(stub) +
                    " expected to yield to '" + stub.callArgPropsLast +
                    "', but no object with such a property was passed."
            } else {
                msg = sinon.functionName(stub) +
                            " expected to yield, but no callback was passed."
            }

            if (args.length > 0) {
                msg += " Received [" + join.call(args, ", ") + "]";
            }

            return msg;
        }

        return "argument at index " + stub.callArgAtsLast + " is not a function: " + func;
    }

    var nextTick = (function () {
        if (typeof process === "object" && typeof process.nextTick === "function") {
            return process.nextTick;
        } else if (typeof setImmediate === "function") {
            return setImmediate;
        } else {
            return function (callback) {
                setTimeout(callback, 0);
            };
        }
    })();

    function callCallback(stub, args) {
        if (stub.callArgAts.length > 0) {
            var func = getCallback(stub, args);

            if (typeof func != "function") {
                throw new TypeError(getCallbackError(stub, func, args));
            }

            var callbackArguments = getChangingValue(stub, "callbackArguments");
            var callbackContext = getChangingValue(stub, "callbackContexts");

            if (stub.callbackAsync) {
                nextTick(function() {
                    func.apply(callbackContext, callbackArguments);
                });
            } else {
                func.apply(callbackContext, callbackArguments);
            }
        }
    }

    var uuid = 0;

    sinon.extend(stub, (function () {
        var slice = Array.prototype.slice, proto;

        function throwsException(error, message) {
            if (typeof error == "string") {
                this.exception = new Error(message || "");
                this.exception.name = error;
            } else if (!error) {
                this.exception = new Error("Error");
            } else {
                this.exception = error;
            }

            return this;
        }

        proto = {
            create: function create() {
                var functionStub = function () {

                    callCallback(functionStub, arguments);

                    if (functionStub.exception) {
                        throw functionStub.exception;
                    } else if (typeof functionStub.returnArgAt == 'number') {
                        return arguments[functionStub.returnArgAt];
                    } else if (functionStub.returnThis) {
                        return this;
                    }
                    return functionStub.returnValue;
                };

                functionStub.id = "stub#" + uuid++;
                var orig = functionStub;
                functionStub = sinon.spy.create(functionStub);
                functionStub.func = orig;

                functionStub.callArgAts = [];
                functionStub.callbackArguments = [];
                functionStub.callbackContexts = [];
                functionStub.callArgProps = [];

                sinon.extend(functionStub, stub);
                functionStub._create = sinon.stub.create;
                functionStub.displayName = "stub";
                functionStub.toString = sinon.functionToString;

                return functionStub;
            },

            resetBehavior: function () {
                var i;

                this.callArgAts = [];
                this.callbackArguments = [];
                this.callbackContexts = [];
                this.callArgProps = [];

                delete this.returnValue;
                delete this.returnArgAt;
                this.returnThis = false;

                if (this.fakes) {
                    for (i = 0; i < this.fakes.length; i++) {
                        this.fakes[i].resetBehavior();
                    }
                }
            },

            returns: function returns(value) {
                this.returnValue = value;

                return this;
            },

            returnsArg: function returnsArg(pos) {
                if (typeof pos != "number") {
                    throw new TypeError("argument index is not number");
                }

                this.returnArgAt = pos;

                return this;
            },

            returnsThis: function returnsThis() {
                this.returnThis = true;

                return this;
            },

            "throws": throwsException,
            throwsException: throwsException,

            callsArg: function callsArg(pos) {
                if (typeof pos != "number") {
                    throw new TypeError("argument index is not number");
                }

                this.callArgAts.push(pos);
                this.callbackArguments.push([]);
                this.callbackContexts.push(undefined);
                this.callArgProps.push(undefined);

                return this;
            },

            callsArgOn: function callsArgOn(pos, context) {
                if (typeof pos != "number") {
                    throw new TypeError("argument index is not number");
                }
                if (typeof context != "object") {
                    throw new TypeError("argument context is not an object");
                }

                this.callArgAts.push(pos);
                this.callbackArguments.push([]);
                this.callbackContexts.push(context);
                this.callArgProps.push(undefined);

                return this;
            },

            callsArgWith: function callsArgWith(pos) {
                if (typeof pos != "number") {
                    throw new TypeError("argument index is not number");
                }

                this.callArgAts.push(pos);
                this.callbackArguments.push(slice.call(arguments, 1));
                this.callbackContexts.push(undefined);
                this.callArgProps.push(undefined);

                return this;
            },

            callsArgOnWith: function callsArgWith(pos, context) {
                if (typeof pos != "number") {
                    throw new TypeError("argument index is not number");
                }
                if (typeof context != "object") {
                    throw new TypeError("argument context is not an object");
                }

                this.callArgAts.push(pos);
                this.callbackArguments.push(slice.call(arguments, 2));
                this.callbackContexts.push(context);
                this.callArgProps.push(undefined);

                return this;
            },

            yields: function () {
                this.callArgAts.push(-1);
                this.callbackArguments.push(slice.call(arguments, 0));
                this.callbackContexts.push(undefined);
                this.callArgProps.push(undefined);

                return this;
            },

            yieldsOn: function (context) {
                if (typeof context != "object") {
                    throw new TypeError("argument context is not an object");
                }

                this.callArgAts.push(-1);
                this.callbackArguments.push(slice.call(arguments, 1));
                this.callbackContexts.push(context);
                this.callArgProps.push(undefined);

                return this;
            },

            yieldsTo: function (prop) {
                this.callArgAts.push(-1);
                this.callbackArguments.push(slice.call(arguments, 1));
                this.callbackContexts.push(undefined);
                this.callArgProps.push(prop);

                return this;
            },

            yieldsToOn: function (prop, context) {
                if (typeof context != "object") {
                    throw new TypeError("argument context is not an object");
                }

                this.callArgAts.push(-1);
                this.callbackArguments.push(slice.call(arguments, 2));
                this.callbackContexts.push(context);
                this.callArgProps.push(prop);

                return this;
            }
        };

        // create asynchronous versions of callsArg* and yields* methods
        for (var method in proto) {
            // need to avoid creating anotherasync versions of the newly added async methods
            if (proto.hasOwnProperty(method) &&
                method.match(/^(callsArg|yields|thenYields$)/) &&
                !method.match(/Async/)) {
                proto[method + 'Async'] = (function (syncFnName) {
                    return function () {
                        this.callbackAsync = true;
                        return this[syncFnName].apply(this, arguments);
                    };
                })(method);
            }
        }

        return proto;

    }()));

    if (commonJSModule) {
        module.exports = stub;
    } else {
        sinon.stub = stub;
    }
}(typeof sinon == "object" && sinon || null));

/**
 * @depend ../sinon.js
 * @depend stub.js
 */
/*jslint eqeqeq: false, onevar: false, nomen: false*/
/*global module, require, sinon*/
/**
 * Mock functions.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

(function (sinon) {
    var commonJSModule = typeof module == "object" && typeof require == "function";
    var push = [].push;

    if (!sinon && commonJSModule) {
        sinon = require("../sinon");
    }

    if (!sinon) {
        return;
    }

    function mock(object) {
        if (!object) {
            return sinon.expectation.create("Anonymous mock");
        }

        return mock.create(object);
    }

    sinon.mock = mock;

    sinon.extend(mock, (function () {
        function each(collection, callback) {
            if (!collection) {
                return;
            }

            for (var i = 0, l = collection.length; i < l; i += 1) {
                callback(collection[i]);
            }
        }

        return {
            create: function create(object) {
                if (!object) {
                    throw new TypeError("object is null");
                }

                var mockObject = sinon.extend({}, mock);
                mockObject.object = object;
                delete mockObject.create;

                return mockObject;
            },

            expects: function expects(method) {
                if (!method) {
                    throw new TypeError("method is falsy");
                }

                if (!this.expectations) {
                    this.expectations = {};
                    this.proxies = [];
                }

                if (!this.expectations[method]) {
                    this.expectations[method] = [];
                    var mockObject = this;

                    sinon.wrapMethod(this.object, method, function () {
                        return mockObject.invokeMethod(method, this, arguments);
                    });

                    push.call(this.proxies, method);
                }

                var expectation = sinon.expectation.create(method);
                push.call(this.expectations[method], expectation);

                return expectation;
            },

            restore: function restore() {
                var object = this.object;

                each(this.proxies, function (proxy) {
                    if (typeof object[proxy].restore == "function") {
                        object[proxy].restore();
                    }
                });
            },

            verify: function verify() {
                var expectations = this.expectations || {};
                var messages = [], met = [];

                each(this.proxies, function (proxy) {
                    each(expectations[proxy], function (expectation) {
                        if (!expectation.met()) {
                            push.call(messages, expectation.toString());
                        } else {
                            push.call(met, expectation.toString());
                        }
                    });
                });

                this.restore();

                if (messages.length > 0) {
                    sinon.expectation.fail(messages.concat(met).join("\n"));
                } else {
                    sinon.expectation.pass(messages.concat(met).join("\n"));
                }

                return true;
            },

            invokeMethod: function invokeMethod(method, thisValue, args) {
                var expectations = this.expectations && this.expectations[method];
                var length = expectations && expectations.length || 0, i;

                for (i = 0; i < length; i += 1) {
                    if (!expectations[i].met() &&
                        expectations[i].allowsCall(thisValue, args)) {
                        return expectations[i].apply(thisValue, args);
                    }
                }

                var messages = [], available, exhausted = 0;

                for (i = 0; i < length; i += 1) {
                    if (expectations[i].allowsCall(thisValue, args)) {
                        available = available || expectations[i];
                    } else {
                        exhausted += 1;
                    }
                    push.call(messages, "    " + expectations[i].toString());
                }

                if (exhausted === 0) {
                    return available.apply(thisValue, args);
                }

                messages.unshift("Unexpected call: " + sinon.spyCall.toString.call({
                    proxy: method,
                    args: args
                }));

                sinon.expectation.fail(messages.join("\n"));
            }
        };
    }()));

    var times = sinon.timesInWords;

    sinon.expectation = (function () {
        var slice = Array.prototype.slice;
        var _invoke = sinon.spy.invoke;

        function callCountInWords(callCount) {
            if (callCount == 0) {
                return "never called";
            } else {
                return "called " + times(callCount);
            }
        }

        function expectedCallCountInWords(expectation) {
            var min = expectation.minCalls;
            var max = expectation.maxCalls;

            if (typeof min == "number" && typeof max == "number") {
                var str = times(min);

                if (min != max) {
                    str = "at least " + str + " and at most " + times(max);
                }

                return str;
            }

            if (typeof min == "number") {
                return "at least " + times(min);
            }

            return "at most " + times(max);
        }

        function receivedMinCalls(expectation) {
            var hasMinLimit = typeof expectation.minCalls == "number";
            return !hasMinLimit || expectation.callCount >= expectation.minCalls;
        }

        function receivedMaxCalls(expectation) {
            if (typeof expectation.maxCalls != "number") {
                return false;
            }

            return expectation.callCount == expectation.maxCalls;
        }

        return {
            minCalls: 1,
            maxCalls: 1,

            create: function create(methodName) {
                var expectation = sinon.extend(sinon.stub.create(), sinon.expectation);
                delete expectation.create;
                expectation.method = methodName;

                return expectation;
            },

            invoke: function invoke(func, thisValue, args) {
                this.verifyCallAllowed(thisValue, args);

                return _invoke.apply(this, arguments);
            },

            atLeast: function atLeast(num) {
                if (typeof num != "number") {
                    throw new TypeError("'" + num + "' is not number");
                }

                if (!this.limitsSet) {
                    this.maxCalls = null;
                    this.limitsSet = true;
                }

                this.minCalls = num;

                return this;
            },

            atMost: function atMost(num) {
                if (typeof num != "number") {
                    throw new TypeError("'" + num + "' is not number");
                }

                if (!this.limitsSet) {
                    this.minCalls = null;
                    this.limitsSet = true;
                }

                this.maxCalls = num;

                return this;
            },

            never: function never() {
                return this.exactly(0);
            },

            once: function once() {
                return this.exactly(1);
            },

            twice: function twice() {
                return this.exactly(2);
            },

            thrice: function thrice() {
                return this.exactly(3);
            },

            exactly: function exactly(num) {
                if (typeof num != "number") {
                    throw new TypeError("'" + num + "' is not a number");
                }

                this.atLeast(num);
                return this.atMost(num);
            },

            met: function met() {
                return !this.failed && receivedMinCalls(this);
            },

            verifyCallAllowed: function verifyCallAllowed(thisValue, args) {
                if (receivedMaxCalls(this)) {
                    this.failed = true;
                    sinon.expectation.fail(this.method + " already called " + times(this.maxCalls));
                }

                if ("expectedThis" in this && this.expectedThis !== thisValue) {
                    sinon.expectation.fail(this.method + " called with " + thisValue + " as thisValue, expected " +
                        this.expectedThis);
                }

                if (!("expectedArguments" in this)) {
                    return;
                }

                if (!args) {
                    sinon.expectation.fail(this.method + " received no arguments, expected " +
                        sinon.format(this.expectedArguments));
                }

                if (args.length < this.expectedArguments.length) {
                    sinon.expectation.fail(this.method + " received too few arguments (" + sinon.format(args) +
                        "), expected " + sinon.format(this.expectedArguments));
                }

                if (this.expectsExactArgCount &&
                    args.length != this.expectedArguments.length) {
                    sinon.expectation.fail(this.method + " received too many arguments (" + sinon.format(args) +
                        "), expected " + sinon.format(this.expectedArguments));
                }

                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
                        sinon.expectation.fail(this.method + " received wrong arguments " + sinon.format(args) +
                            ", expected " + sinon.format(this.expectedArguments));
                    }
                }
            },

            allowsCall: function allowsCall(thisValue, args) {
                if (this.met() && receivedMaxCalls(this)) {
                    return false;
                }

                if ("expectedThis" in this && this.expectedThis !== thisValue) {
                    return false;
                }

                if (!("expectedArguments" in this)) {
                    return true;
                }

                args = args || [];

                if (args.length < this.expectedArguments.length) {
                    return false;
                }

                if (this.expectsExactArgCount &&
                    args.length != this.expectedArguments.length) {
                    return false;
                }

                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
                        return false;
                    }
                }

                return true;
            },

            withArgs: function withArgs() {
                this.expectedArguments = slice.call(arguments);
                return this;
            },

            withExactArgs: function withExactArgs() {
                this.withArgs.apply(this, arguments);
                this.expectsExactArgCount = true;
                return this;
            },

            on: function on(thisValue) {
                this.expectedThis = thisValue;
                return this;
            },

            toString: function () {
                var args = (this.expectedArguments || []).slice();

                if (!this.expectsExactArgCount) {
                    push.call(args, "[...]");
                }

                var callStr = sinon.spyCall.toString.call({
                    proxy: this.method || "anonymous mock expectation",
                    args: args
                });

                var message = callStr.replace(", [...", "[, ...") + " " +
                    expectedCallCountInWords(this);

                if (this.met()) {
                    return "Expectation met: " + message;
                }

                return "Expected " + message + " (" +
                    callCountInWords(this.callCount) + ")";
            },

            verify: function verify() {
                if (!this.met()) {
                    sinon.expectation.fail(this.toString());
                } else {
                    sinon.expectation.pass(this.toString());
                }

                return true;
            },

            pass: function(message) {
              sinon.assert.pass(message);
            },
            fail: function (message) {
                var exception = new Error(message);
                exception.name = "ExpectationError";

                throw exception;
            }
        };
    }());

    if (commonJSModule) {
        module.exports = mock;
    } else {
        sinon.mock = mock;
    }
}(typeof sinon == "object" && sinon || null));

/**
 * @depend ../sinon.js
 * @depend stub.js
 * @depend mock.js
 */
/*jslint eqeqeq: false, onevar: false, forin: true*/
/*global module, require, sinon*/
/**
 * Collections of stubs, spies and mocks.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

(function (sinon) {
    var commonJSModule = typeof module == "object" && typeof require == "function";
    var push = [].push;
    var hasOwnProperty = Object.prototype.hasOwnProperty;

    if (!sinon && commonJSModule) {
        sinon = require("../sinon");
    }

    if (!sinon) {
        return;
    }

    function getFakes(fakeCollection) {
        if (!fakeCollection.fakes) {
            fakeCollection.fakes = [];
        }

        return fakeCollection.fakes;
    }

    function each(fakeCollection, method) {
        var fakes = getFakes(fakeCollection);

        for (var i = 0, l = fakes.length; i < l; i += 1) {
            if (typeof fakes[i][method] == "function") {
                fakes[i][method]();
            }
        }
    }

    function compact(fakeCollection) {
        var fakes = getFakes(fakeCollection);
        var i = 0;
        while (i < fakes.length) {
          fakes.splice(i, 1);
        }
    }

    var collection = {
        verify: function resolve() {
            each(this, "verify");
        },

        restore: function restore() {
            each(this, "restore");
            compact(this);
        },

        verifyAndRestore: function verifyAndRestore() {
            var exception;

            try {
                this.verify();
            } catch (e) {
                exception = e;
            }

            this.restore();

            if (exception) {
                throw exception;
            }
        },

        add: function add(fake) {
            push.call(getFakes(this), fake);
            return fake;
        },

        spy: function spy() {
            return this.add(sinon.spy.apply(sinon, arguments));
        },

        stub: function stub(object, property, value) {
            if (property) {
                var original = object[property];

                if (typeof original != "function") {
                    if (!hasOwnProperty.call(object, property)) {
                        throw new TypeError("Cannot stub non-existent own property " + property);
                    }

                    object[property] = value;

                    return this.add({
                        restore: function () {
                            object[property] = original;
                        }
                    });
                }
            }
            if (!property && !!object && typeof object == "object") {
                var stubbedObj = sinon.stub.apply(sinon, arguments);

                for (var prop in stubbedObj) {
                    if (typeof stubbedObj[prop] === "function") {
                        this.add(stubbedObj[prop]);
                    }
                }

                return stubbedObj;
            }

            return this.add(sinon.stub.apply(sinon, arguments));
        },

        mock: function mock() {
            return this.add(sinon.mock.apply(sinon, arguments));
        },

        inject: function inject(obj) {
            var col = this;

            obj.spy = function () {
                return col.spy.apply(col, arguments);
            };

            obj.stub = function () {
                return col.stub.apply(col, arguments);
            };

            obj.mock = function () {
                return col.mock.apply(col, arguments);
            };

            return obj;
        }
    };

    if (commonJSModule) {
        module.exports = collection;
    } else {
        sinon.collection = collection;
    }
}(typeof sinon == "object" && sinon || null));

/*jslint eqeqeq: false, plusplus: false, evil: true, onevar: false, browser: true, forin: false*/
/*global module, require, window*/
/**
 * Fake timer API
 * setTimeout
 * setInterval
 * clearTimeout
 * clearInterval
 * tick
 * reset
 * Date
 *
 * Inspired by jsUnitMockTimeOut from JsUnit
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

if (typeof sinon == "undefined") {
    var sinon = {};
}

(function (global) {
    var id = 1;

    function addTimer(args, recurring) {
        if (args.length === 0) {
            throw new Error("Function requires at least 1 parameter");
        }

        var toId = id++;
        var delay = args[1] || 0;

        if (!this.timeouts) {
            this.timeouts = {};
        }

        this.timeouts[toId] = {
            id: toId,
            func: args[0],
            callAt: this.now + delay,
            invokeArgs: Array.prototype.slice.call(args, 2)
        };

        if (recurring === true) {
            this.timeouts[toId].interval = delay;
        }

        return toId;
    }

    function parseTime(str) {
        if (!str) {
            return 0;
        }

        var strings = str.split(":");
        var l = strings.length, i = l;
        var ms = 0, parsed;

        if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
            throw new Error("tick only understands numbers and 'h:m:s'");
        }

        while (i--) {
            parsed = parseInt(strings[i], 10);

            if (parsed >= 60) {
                throw new Error("Invalid time " + str);
            }

            ms += parsed * Math.pow(60, (l - i - 1));
        }

        return ms * 1000;
    }

    function createObject(object) {
        var newObject;

        if (Object.create) {
            newObject = Object.create(object);
        } else {
            var F = function () {};
            F.prototype = object;
            newObject = new F();
        }

        newObject.Date.clock = newObject;
        return newObject;
    }

    sinon.clock = {
        now: 0,

        create: function create(now) {
            var clock = createObject(this);

            if (typeof now == "number") {
                clock.now = now;
            }

            if (!!now && typeof now == "object") {
                throw new TypeError("now should be milliseconds since UNIX epoch");
            }

            return clock;
        },

        setTimeout: function setTimeout(callback, timeout) {
            return addTimer.call(this, arguments, false);
        },

        clearTimeout: function clearTimeout(timerId) {
            if (!this.timeouts) {
                this.timeouts = [];
            }

            if (timerId in this.timeouts) {
                delete this.timeouts[timerId];
            }
        },

        setInterval: function setInterval(callback, timeout) {
            return addTimer.call(this, arguments, true);
        },

        clearInterval: function clearInterval(timerId) {
            this.clearTimeout(timerId);
        },

        tick: function tick(ms) {
            ms = typeof ms == "number" ? ms : parseTime(ms);
            var tickFrom = this.now, tickTo = this.now + ms, previous = this.now;
            var timer = this.firstTimerInRange(tickFrom, tickTo);

            var firstException;
            while (timer && tickFrom <= tickTo) {
                if (this.timeouts[timer.id]) {
                    tickFrom = this.now = timer.callAt;
                    try {
                      this.callTimer(timer);
                    } catch (e) {
                      firstException = firstException || e;
                    }
                }

                timer = this.firstTimerInRange(previous, tickTo);
                previous = tickFrom;
            }

            this.now = tickTo;

            if (firstException) {
              throw firstException;
            }

            return this.now;
        },

        firstTimerInRange: function (from, to) {
            var timer, smallest, originalTimer;

            for (var id in this.timeouts) {
                if (this.timeouts.hasOwnProperty(id)) {
                    if (this.timeouts[id].callAt < from || this.timeouts[id].callAt > to) {
                        continue;
                    }

                    if (!smallest || this.timeouts[id].callAt < smallest) {
                        originalTimer = this.timeouts[id];
                        smallest = this.timeouts[id].callAt;

                        timer = {
                            func: this.timeouts[id].func,
                            callAt: this.timeouts[id].callAt,
                            interval: this.timeouts[id].interval,
                            id: this.timeouts[id].id,
                            invokeArgs: this.timeouts[id].invokeArgs
                        };
                    }
                }
            }

            return timer || null;
        },

        callTimer: function (timer) {
            if (typeof timer.interval == "number") {
                this.timeouts[timer.id].callAt += timer.interval;
            } else {
                delete this.timeouts[timer.id];
            }

            try {
                if (typeof timer.func == "function") {
                    timer.func.apply(null, timer.invokeArgs);
                } else {
                    eval(timer.func);
                }
            } catch (e) {
              var exception = e;
            }

            if (!this.timeouts[timer.id]) {
                if (exception) {
                  throw exception;
                }
                return;
            }

            if (exception) {
              throw exception;
            }
        },

        reset: function reset() {
            this.timeouts = {};
        },

        Date: (function () {
            var NativeDate = Date;

            function ClockDate(year, month, date, hour, minute, second, ms) {
                // Defensive and verbose to avoid potential harm in passing
                // explicit undefined when user does not pass argument
                switch (arguments.length) {
                case 0:
                    return new NativeDate(ClockDate.clock.now);
                case 1:
                    return new NativeDate(year);
                case 2:
                    return new NativeDate(year, month);
                case 3:
                    return new NativeDate(year, month, date);
                case 4:
                    return new NativeDate(year, month, date, hour);
                case 5:
                    return new NativeDate(year, month, date, hour, minute);
                case 6:
                    return new NativeDate(year, month, date, hour, minute, second);
                default:
                    return new NativeDate(year, month, date, hour, minute, second, ms);
                }
            }

            return mirrorDateProperties(ClockDate, NativeDate);
        }())
    };

    function mirrorDateProperties(target, source) {
        if (source.now) {
            target.now = function now() {
                return target.clock.now;
            };
        } else {
            delete target.now;
        }

        if (source.toSource) {
            target.toSource = function toSource() {
                return source.toSource();
            };
        } else {
            delete target.toSource;
        }

        target.toString = function toString() {
            return source.toString();
        };

        target.prototype = source.prototype;
        target.parse = source.parse;
        target.UTC = source.UTC;
        target.prototype.toUTCString = source.prototype.toUTCString;
        return target;
    }

    var methods = ["Date", "setTimeout", "setInterval",
                   "clearTimeout", "clearInterval"];

    function restore() {
        var method;

        for (var i = 0, l = this.methods.length; i < l; i++) {
            method = this.methods[i];
            if (global[method].hadOwnProperty) {
                global[method] = this["_" + method];
            } else {
                delete global[method];
            }
        }

        // Prevent multiple executions which will completely remove these props
        this.methods = [];
    }

    function stubGlobal(method, clock) {
        clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(global, method);
        clock["_" + method] = global[method];

        if (method == "Date") {
            var date = mirrorDateProperties(clock[method], global[method]);
            global[method] = date;
        } else {
            global[method] = function () {
                return clock[method].apply(clock, arguments);
            };

            for (var prop in clock[method]) {
                if (clock[method].hasOwnProperty(prop)) {
                    global[method][prop] = clock[method][prop];
                }
            }
        }

        global[method].clock = clock;
    }

    sinon.useFakeTimers = function useFakeTimers(now) {
        var clock = sinon.clock.create(now);
        clock.restore = restore;
        clock.methods = Array.prototype.slice.call(arguments,
                                                   typeof now == "number" ? 1 : 0);

        if (clock.methods.length === 0) {
            clock.methods = methods;
        }

        for (var i = 0, l = clock.methods.length; i < l; i++) {
            stubGlobal(clock.methods[i], clock);
        }

        return clock;
    };
}(typeof global != "undefined" && typeof global !== "function" ? global : this));

sinon.timers = {
    setTimeout: setTimeout,
    clearTimeout: clearTimeout,
    setInterval: setInterval,
    clearInterval: clearInterval,
    Date: Date
};

if (typeof module == "object" && typeof require == "function") {
    module.exports = sinon;
}

/*jslint eqeqeq: false, onevar: false*/
/*global sinon, module, require, ActiveXObject, XMLHttpRequest, DOMParser*/
/**
 * Minimal Event interface implementation
 *
 * Original implementation by Sven Fuchs: https://gist.github.com/995028
 * Modifications and tests by Christian Johansen.
 *
 * @author Sven Fuchs (svenfuchs@artweb-design.de)
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2011 Sven Fuchs, Christian Johansen
 */

if (typeof sinon == "undefined") {
    this.sinon = {};
}

(function () {
    var push = [].push;

    sinon.Event = function Event(type, bubbles, cancelable, target) {
        this.initEvent(type, bubbles, cancelable, target);
    };

    sinon.Event.prototype = {
        initEvent: function(type, bubbles, cancelable, target) {
            this.type = type;
            this.bubbles = bubbles;
            this.cancelable = cancelable;
            this.target = target;
        },

        stopPropagation: function () {},

        preventDefault: function () {
            this.defaultPrevented = true;
        }
    };

    sinon.EventTarget = {
        addEventListener: function addEventListener(event, listener, useCapture) {
            this.eventListeners = this.eventListeners || {};
            this.eventListeners[event] = this.eventListeners[event] || [];
            push.call(this.eventListeners[event], listener);
        },

        removeEventListener: function removeEventListener(event, listener, useCapture) {
            var listeners = this.eventListeners && this.eventListeners[event] || [];

            for (var i = 0, l = listeners.length; i < l; ++i) {
                if (listeners[i] == listener) {
                    return listeners.splice(i, 1);
                }
            }
        },

        dispatchEvent: function dispatchEvent(event) {
            var type = event.type;
            var listeners = this.eventListeners && this.eventListeners[type] || [];

            for (var i = 0; i < listeners.length; i++) {
                if (typeof listeners[i] == "function") {
                    listeners[i].call(this, event);
                } else {
                    listeners[i].handleEvent(event);
                }
            }

            return !!event.defaultPrevented;
        }
    };
}());

/**
 * @depend ../../sinon.js
 * @depend event.js
 */
/*jslint eqeqeq: false, onevar: false*/
/*global sinon, module, require, ActiveXObject, XMLHttpRequest, DOMParser*/
/**
 * Fake XMLHttpRequest object
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

if (typeof sinon == "undefined") {
    this.sinon = {};
}
sinon.xhr = { XMLHttpRequest: this.XMLHttpRequest };

// wrapper for global
(function(global) {
    var xhr = sinon.xhr;
    xhr.GlobalXMLHttpRequest = global.XMLHttpRequest;
    xhr.GlobalActiveXObject = global.ActiveXObject;
    xhr.supportsActiveX = typeof xhr.GlobalActiveXObject != "undefined";
    xhr.supportsXHR = typeof xhr.GlobalXMLHttpRequest != "undefined";
    xhr.workingXHR = xhr.supportsXHR ? xhr.GlobalXMLHttpRequest : xhr.supportsActiveX
                                     ? function() { return new xhr.GlobalActiveXObject("MSXML2.XMLHTTP.3.0") } : false;

    /*jsl:ignore*/
    var unsafeHeaders = {
        "Accept-Charset": true,
        "Accept-Encoding": true,
        "Connection": true,
        "Content-Length": true,
        "Cookie": true,
        "Cookie2": true,
        "Content-Transfer-Encoding": true,
        "Date": true,
        "Expect": true,
        "Host": true,
        "Keep-Alive": true,
        "Referer": true,
        "TE": true,
        "Trailer": true,
        "Transfer-Encoding": true,
        "Upgrade": true,
        "User-Agent": true,
        "Via": true
    };
    /*jsl:end*/

    function FakeXMLHttpRequest() {
        this.readyState = FakeXMLHttpRequest.UNSENT;
        this.requestHeaders = {};
        this.requestBody = null;
        this.status = 0;
        this.statusText = "";

        var xhr = this;

        ["loadstart", "load", "abort", "loadend"].forEach(function (eventName) {
            xhr.addEventListener(eventName, function (event) {
                var listener = xhr["on" + eventName];

                if (listener && typeof listener == "function") {
                    listener(event);
                }
            });
        });

        if (typeof FakeXMLHttpRequest.onCreate == "function") {
            FakeXMLHttpRequest.onCreate(this);
        }
    }

    function verifyState(xhr) {
        if (xhr.readyState !== FakeXMLHttpRequest.OPENED) {
            throw new Error("INVALID_STATE_ERR");
        }

        if (xhr.sendFlag) {
            throw new Error("INVALID_STATE_ERR");
        }
    }

    // filtering to enable a white-list version of Sinon FakeXhr,
    // where whitelisted requests are passed through to real XHR
    function each(collection, callback) {
        if (!collection) return;
        for (var i = 0, l = collection.length; i < l; i += 1) {
            callback(collection[i]);
        }
    }
    function some(collection, callback) {
        for (var index = 0; index < collection.length; index++) {
            if(callback(collection[index]) === true) return true;
        };
        return false;
    }
    // largest arity in XHR is 5 - XHR#open
    var apply = function(obj,method,args) {
        switch(args.length) {
        case 0: return obj[method]();
        case 1: return obj[method](args[0]);
        case 2: return obj[method](args[0],args[1]);
        case 3: return obj[method](args[0],args[1],args[2]);
        case 4: return obj[method](args[0],args[1],args[2],args[3]);
        case 5: return obj[method](args[0],args[1],args[2],args[3],args[4]);
        };
    };

    FakeXMLHttpRequest.filters = [];
    FakeXMLHttpRequest.addFilter = function(fn) {
        this.filters.push(fn)
    };
    var IE6Re = /MSIE 6/;
    FakeXMLHttpRequest.defake = function(fakeXhr,xhrArgs) {
        var xhr = new sinon.xhr.workingXHR();
        each(["open","setRequestHeader","send","abort","getResponseHeader",
              "getAllResponseHeaders","addEventListener","overrideMimeType","removeEventListener"],
             function(method) {
                 fakeXhr[method] = function() {
                   return apply(xhr,method,arguments);
                 };
             });

        var copyAttrs = function(args) {
            each(args, function(attr) {
              try {
                fakeXhr[attr] = xhr[attr]
              } catch(e) {
                if(!IE6Re.test(navigator.userAgent)) throw e;
              }
            });
        };

        var stateChange = function() {
            fakeXhr.readyState = xhr.readyState;
            if(xhr.readyState >= FakeXMLHttpRequest.HEADERS_RECEIVED) {
                copyAttrs(["status","statusText"]);
            }
            if(xhr.readyState >= FakeXMLHttpRequest.LOADING) {
                copyAttrs(["responseText"]);
            }
            if(xhr.readyState === FakeXMLHttpRequest.DONE) {
                copyAttrs(["responseXML"]);
            }
            if(fakeXhr.onreadystatechange) fakeXhr.onreadystatechange.call(fakeXhr);
        };
        if(xhr.addEventListener) {
          for(var event in fakeXhr.eventListeners) {
              if(fakeXhr.eventListeners.hasOwnProperty(event)) {
                  each(fakeXhr.eventListeners[event],function(handler) {
                      xhr.addEventListener(event, handler);
                  });
              }
          }
          xhr.addEventListener("readystatechange",stateChange);
        } else {
          xhr.onreadystatechange = stateChange;
        }
        apply(xhr,"open",xhrArgs);
    };
    FakeXMLHttpRequest.useFilters = false;

    function verifyRequestSent(xhr) {
        if (xhr.readyState == FakeXMLHttpRequest.DONE) {
            throw new Error("Request done");
        }
    }

    function verifyHeadersReceived(xhr) {
        if (xhr.async && xhr.readyState != FakeXMLHttpRequest.HEADERS_RECEIVED) {
            throw new Error("No headers received");
        }
    }

    function verifyResponseBodyType(body) {
        if (typeof body != "string") {
            var error = new Error("Attempted to respond to fake XMLHttpRequest with " +
                                 body + ", which is not a string.");
            error.name = "InvalidBodyException";
            throw error;
        }
    }

    sinon.extend(FakeXMLHttpRequest.prototype, sinon.EventTarget, {
        async: true,

        open: function open(method, url, async, username, password) {
            this.method = method;
            this.url = url;
            this.async = typeof async == "boolean" ? async : true;
            this.username = username;
            this.password = password;
            this.responseText = null;
            this.responseXML = null;
            this.requestHeaders = {};
            this.sendFlag = false;
            if(sinon.FakeXMLHttpRequest.useFilters === true) {
                var xhrArgs = arguments;
                var defake = some(FakeXMLHttpRequest.filters,function(filter) {
                    return filter.apply(this,xhrArgs)
                });
                if (defake) {
                  return sinon.FakeXMLHttpRequest.defake(this,arguments);
                }
            }
            this.readyStateChange(FakeXMLHttpRequest.OPENED);
        },

        readyStateChange: function readyStateChange(state) {
            this.readyState = state;

            if (typeof this.onreadystatechange == "function") {
                try {
                    this.onreadystatechange();
                } catch (e) {
                    sinon.logError("Fake XHR onreadystatechange handler", e);
                }
            }

            this.dispatchEvent(new sinon.Event("readystatechange"));

            switch (this.readyState) {
                case FakeXMLHttpRequest.DONE:
                    this.dispatchEvent(new sinon.Event("load", false, false, this));
                    this.dispatchEvent(new sinon.Event("loadend", false, false, this));
                    break;
            }
        },

        setRequestHeader: function setRequestHeader(header, value) {
            verifyState(this);

            if (unsafeHeaders[header] || /^(Sec-|Proxy-)/.test(header)) {
                throw new Error("Refused to set unsafe header \"" + header + "\"");
            }

            if (this.requestHeaders[header]) {
                this.requestHeaders[header] += "," + value;
            } else {
                this.requestHeaders[header] = value;
            }
        },

        // Helps testing
        setResponseHeaders: function setResponseHeaders(headers) {
            this.responseHeaders = {};

            for (var header in headers) {
                if (headers.hasOwnProperty(header)) {
                    this.responseHeaders[header] = headers[header];
                }
            }

            if (this.async) {
                this.readyStateChange(FakeXMLHttpRequest.HEADERS_RECEIVED);
            } else {
                this.readyState = FakeXMLHttpRequest.HEADERS_RECEIVED;
            }
        },

        // Currently treats ALL data as a DOMString (i.e. no Document)
        send: function send(data) {
            verifyState(this);

            if (!/^(get|head)$/i.test(this.method)) {
                if (this.requestHeaders["Content-Type"]) {
                    var value = this.requestHeaders["Content-Type"].split(";");
                    this.requestHeaders["Content-Type"] = value[0] + ";charset=utf-8";
                } else {
                    this.requestHeaders["Content-Type"] = "text/plain;charset=utf-8";
                }

                this.requestBody = data;
            }

            this.errorFlag = false;
            this.sendFlag = this.async;
            this.readyStateChange(FakeXMLHttpRequest.OPENED);

            if (typeof this.onSend == "function") {
                this.onSend(this);
            }

            this.dispatchEvent(new sinon.Event("loadstart", false, false, this));
        },

        abort: function abort() {
            this.aborted = true;
            this.responseText = null;
            this.errorFlag = true;
            this.requestHeaders = {};

            if (this.readyState > sinon.FakeXMLHttpRequest.UNSENT && this.sendFlag) {
                this.readyStateChange(sinon.FakeXMLHttpRequest.DONE);
                this.sendFlag = false;
            }

            this.readyState = sinon.FakeXMLHttpRequest.UNSENT;

            this.dispatchEvent(new sinon.Event("abort", false, false, this));
            if (typeof this.onerror === "function") {
                this.onerror();
            }
        },

        getResponseHeader: function getResponseHeader(header) {
            if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
                return null;
            }

            if (/^Set-Cookie2?$/i.test(header)) {
                return null;
            }

            header = header.toLowerCase();

            for (var h in this.responseHeaders) {
                if (h.toLowerCase() == header) {
                    return this.responseHeaders[h];
                }
            }

            return null;
        },

        getAllResponseHeaders: function getAllResponseHeaders() {
            if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
                return "";
            }

            var headers = "";

            for (var header in this.responseHeaders) {
                if (this.responseHeaders.hasOwnProperty(header) &&
                    !/^Set-Cookie2?$/i.test(header)) {
                    headers += header + ": " + this.responseHeaders[header] + "\r\n";
                }
            }

            return headers;
        },

        setResponseBody: function setResponseBody(body) {
            verifyRequestSent(this);
            verifyHeadersReceived(this);
            verifyResponseBodyType(body);

            var chunkSize = this.chunkSize || 10;
            var index = 0;
            this.responseText = "";

            do {
                if (this.async) {
                    this.readyStateChange(FakeXMLHttpRequest.LOADING);
                }

                this.responseText += body.substring(index, index + chunkSize);
                index += chunkSize;
            } while (index < body.length);

            var type = this.getResponseHeader("Content-Type");

            if (this.responseText &&
                (!type || /(text\/xml)|(application\/xml)|(\+xml)/.test(type))) {
                try {
                    this.responseXML = FakeXMLHttpRequest.parseXML(this.responseText);
                } catch (e) {
                    // Unable to parse XML - no biggie
                }
            }

            if (this.async) {
                this.readyStateChange(FakeXMLHttpRequest.DONE);
            } else {
                this.readyState = FakeXMLHttpRequest.DONE;
            }
        },

        respond: function respond(status, headers, body) {
            this.setResponseHeaders(headers || {});
            this.status = typeof status == "number" ? status : 200;
            this.statusText = FakeXMLHttpRequest.statusCodes[this.status];
            this.setResponseBody(body || "");
            if (typeof this.onload === "function"){
                this.onload();
            }
            
        }
    });

    sinon.extend(FakeXMLHttpRequest, {
        UNSENT: 0,
        OPENED: 1,
        HEADERS_RECEIVED: 2,
        LOADING: 3,
        DONE: 4
    });

    // Borrowed from JSpec
    FakeXMLHttpRequest.parseXML = function parseXML(text) {
        var xmlDoc;

        if (typeof DOMParser != "undefined") {
            var parser = new DOMParser();
            xmlDoc = parser.parseFromString(text, "text/xml");
        } else {
            xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
            xmlDoc.async = "false";
            xmlDoc.loadXML(text);
        }

        return xmlDoc;
    };

    FakeXMLHttpRequest.statusCodes = {
        100: "Continue",
        101: "Switching Protocols",
        200: "OK",
        201: "Created",
        202: "Accepted",
        203: "Non-Authoritative Information",
        204: "No Content",
        205: "Reset Content",
        206: "Partial Content",
        300: "Multiple Choice",
        301: "Moved Permanently",
        302: "Found",
        303: "See Other",
        304: "Not Modified",
        305: "Use Proxy",
        307: "Temporary Redirect",
        400: "Bad Request",
        401: "Unauthorized",
        402: "Payment Required",
        403: "Forbidden",
        404: "Not Found",
        405: "Method Not Allowed",
        406: "Not Acceptable",
        407: "Proxy Authentication Required",
        408: "Request Timeout",
        409: "Conflict",
        410: "Gone",
        411: "Length Required",
        412: "Precondition Failed",
        413: "Request Entity Too Large",
        414: "Request-URI Too Long",
        415: "Unsupported Media Type",
        416: "Requested Range Not Satisfiable",
        417: "Expectation Failed",
        422: "Unprocessable Entity",
        500: "Internal Server Error",
        501: "Not Implemented",
        502: "Bad Gateway",
        503: "Service Unavailable",
        504: "Gateway Timeout",
        505: "HTTP Version Not Supported"
    };

    sinon.useFakeXMLHttpRequest = function () {
        sinon.FakeXMLHttpRequest.restore = function restore(keepOnCreate) {
            if (xhr.supportsXHR) {
                global.XMLHttpRequest = xhr.GlobalXMLHttpRequest;
            }

            if (xhr.supportsActiveX) {
                global.ActiveXObject = xhr.GlobalActiveXObject;
            }

            delete sinon.FakeXMLHttpRequest.restore;

            if (keepOnCreate !== true) {
                delete sinon.FakeXMLHttpRequest.onCreate;
            }
        };
        if (xhr.supportsXHR) {
            global.XMLHttpRequest = sinon.FakeXMLHttpRequest;
        }

        if (xhr.supportsActiveX) {
            global.ActiveXObject = function ActiveXObject(objId) {
                if (objId == "Microsoft.XMLHTTP" || /^Msxml2\.XMLHTTP/i.test(objId)) {

                    return new sinon.FakeXMLHttpRequest();
                }

                return new xhr.GlobalActiveXObject(objId);
            };
        }

        return sinon.FakeXMLHttpRequest;
    };

    sinon.FakeXMLHttpRequest = FakeXMLHttpRequest;
})(this);

if (typeof module == "object" && typeof require == "function") {
    module.exports = sinon;
}

/**
 * @depend fake_xml_http_request.js
 */
/*jslint eqeqeq: false, onevar: false, regexp: false, plusplus: false*/
/*global module, require, window*/
/**
 * The Sinon "server" mimics a web server that receives requests from
 * sinon.FakeXMLHttpRequest and provides an API to respond to those requests,
 * both synchronously and asynchronously. To respond synchronuously, canned
 * answers have to be provided upfront.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

if (typeof sinon == "undefined") {
    var sinon = {};
}

sinon.fakeServer = (function () {
    var push = [].push;
    function F() {}

    function create(proto) {
        F.prototype = proto;
        return new F();
    }

    function responseArray(handler) {
        var response = handler;

        if (Object.prototype.toString.call(handler) != "[object Array]") {
            response = [200, {}, handler];
        }

        if (typeof response[2] != "string") {
            throw new TypeError("Fake server response body should be string, but was " +
                                typeof response[2]);
        }

        return response;
    }

    var wloc = typeof window !== "undefined" ? window.location : {};
    var rCurrLoc = new RegExp("^" + wloc.protocol + "//" + wloc.host);

    function matchOne(response, reqMethod, reqUrl) {
        var rmeth = response.method;
        var matchMethod = !rmeth || rmeth.toLowerCase() == reqMethod.toLowerCase();
        var url = response.url;
        var matchUrl = !url || url == reqUrl || (typeof url.test == "function" && url.test(reqUrl));

        return matchMethod && matchUrl;
    }

    function match(response, request) {
        var requestMethod = this.getHTTPMethod(request);
        var requestUrl = request.url;

        if (!/^https?:\/\//.test(requestUrl) || rCurrLoc.test(requestUrl)) {
            requestUrl = requestUrl.replace(rCurrLoc, "");
        }

        if (matchOne(response, this.getHTTPMethod(request), requestUrl)) {
            if (typeof response.response == "function") {
                var ru = response.url;
                var args = [request].concat(!ru ? [] : requestUrl.match(ru).slice(1));
                return response.response.apply(response, args);
            }

            return true;
        }

        return false;
    }

    function log(response, request) {
        var str;

        str =  "Request:\n"  + sinon.format(request)  + "\n\n";
        str += "Response:\n" + sinon.format(response) + "\n\n";

        sinon.log(str);
    }

    return {
        create: function () {
            var server = create(this);
            this.xhr = sinon.useFakeXMLHttpRequest();
            server.requests = [];

            this.xhr.onCreate = function (xhrObj) {
                server.addRequest(xhrObj);
            };

            return server;
        },

        addRequest: function addRequest(xhrObj) {
            var server = this;
            push.call(this.requests, xhrObj);

            xhrObj.onSend = function () {
                server.handleRequest(this);
            };

            if (this.autoRespond && !this.responding) {
                setTimeout(function () {
                    server.responding = false;
                    server.respond();
                }, this.autoRespondAfter || 10);

                this.responding = true;
            }
        },

        getHTTPMethod: function getHTTPMethod(request) {
            if (this.fakeHTTPMethods && /post/i.test(request.method)) {
                var matches = (request.requestBody || "").match(/_method=([^\b;]+)/);
                return !!matches ? matches[1] : request.method;
            }

            return request.method;
        },

        handleRequest: function handleRequest(xhr) {
            if (xhr.async) {
                if (!this.queue) {
                    this.queue = [];
                }

                push.call(this.queue, xhr);
            } else {
                this.processRequest(xhr);
            }
        },

        respondWith: function respondWith(method, url, body) {
            if (arguments.length == 1 && typeof method != "function") {
                this.response = responseArray(method);
                return;
            }

            if (!this.responses) { this.responses = []; }

            if (arguments.length == 1) {
                body = method;
                url = method = null;
            }

            if (arguments.length == 2) {
                body = url;
                url = method;
                method = null;
            }

            push.call(this.responses, {
                method: method,
                url: url,
                response: typeof body == "function" ? body : responseArray(body)
            });
        },

        respond: function respond() {
            if (arguments.length > 0) this.respondWith.apply(this, arguments);
            var queue = this.queue || [];
            var request;

            while(request = queue.shift()) {
                this.processRequest(request);
            }
        },

        processRequest: function processRequest(request) {
            try {
                if (request.aborted) {
                    return;
                }

                var response = this.response || [404, {}, ""];

                if (this.responses) {
                    for (var i = 0, l = this.responses.length; i < l; i++) {
                        if (match.call(this, this.responses[i], request)) {
                            response = this.responses[i].response;
                            break;
                        }
                    }
                }

                if (request.readyState != 4) {
                    log(response, request);

                    request.respond(response[0], response[1], response[2]);
                }
            } catch (e) {
                sinon.logError("Fake server request processing", e);
            }
        },

        restore: function restore() {
            return this.xhr.restore && this.xhr.restore.apply(this.xhr, arguments);
        }
    };
}());

if (typeof module == "object" && typeof require == "function") {
    module.exports = sinon;
}

/**
 * @depend fake_server.js
 * @depend fake_timers.js
 */
/*jslint browser: true, eqeqeq: false, onevar: false*/
/*global sinon*/
/**
 * Add-on for sinon.fakeServer that automatically handles a fake timer along with
 * the FakeXMLHttpRequest. The direct inspiration for this add-on is jQuery
 * 1.3.x, which does not use xhr object's onreadystatehandler at all - instead,
 * it polls the object for completion with setInterval. Dispite the direct
 * motivation, there is nothing jQuery-specific in this file, so it can be used
 * in any environment where the ajax implementation depends on setInterval or
 * setTimeout.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

(function () {
    function Server() {}
    Server.prototype = sinon.fakeServer;

    sinon.fakeServerWithClock = new Server();

    sinon.fakeServerWithClock.addRequest = function addRequest(xhr) {
        if (xhr.async) {
            if (typeof setTimeout.clock == "object") {
                this.clock = setTimeout.clock;
            } else {
                this.clock = sinon.useFakeTimers();
                this.resetClock = true;
            }

            if (!this.longestTimeout) {
                var clockSetTimeout = this.clock.setTimeout;
                var clockSetInterval = this.clock.setInterval;
                var server = this;

                this.clock.setTimeout = function (fn, timeout) {
                    server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);

                    return clockSetTimeout.apply(this, arguments);
                };

                this.clock.setInterval = function (fn, timeout) {
                    server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);

                    return clockSetInterval.apply(this, arguments);
                };
            }
        }

        return sinon.fakeServer.addRequest.call(this, xhr);
    };

    sinon.fakeServerWithClock.respond = function respond() {
        var returnVal = sinon.fakeServer.respond.apply(this, arguments);

        if (this.clock) {
            this.clock.tick(this.longestTimeout || 0);
            this.longestTimeout = 0;

            if (this.resetClock) {
                this.clock.restore();
                this.resetClock = false;
            }
        }

        return returnVal;
    };

    sinon.fakeServerWithClock.restore = function restore() {
        if (this.clock) {
            this.clock.restore();
        }

        return sinon.fakeServer.restore.apply(this, arguments);
    };
}());

/**
 * @depend ../sinon.js
 * @depend collection.js
 * @depend util/fake_timers.js
 * @depend util/fake_server_with_clock.js
 */
/*jslint eqeqeq: false, onevar: false, plusplus: false*/
/*global require, module*/
/**
 * Manages fake collections as well as fake utilities such as Sinon's
 * timers and fake XHR implementation in one convenient object.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

if (typeof module == "object" && typeof require == "function") {
    var sinon = require("../sinon");
    sinon.extend(sinon, require("./util/fake_timers"));
}

(function () {
    var push = [].push;

    function exposeValue(sandbox, config, key, value) {
        if (!value) {
            return;
        }

        if (config.injectInto) {
            config.injectInto[key] = value;
        } else {
            push.call(sandbox.args, value);
        }
    }

    function prepareSandboxFromConfig(config) {
        var sandbox = sinon.create(sinon.sandbox);

        if (config.useFakeServer) {
            if (typeof config.useFakeServer == "object") {
                sandbox.serverPrototype = config.useFakeServer;
            }

            sandbox.useFakeServer();
        }

        if (config.useFakeTimers) {
            if (typeof config.useFakeTimers == "object") {
                sandbox.useFakeTimers.apply(sandbox, config.useFakeTimers);
            } else {
                sandbox.useFakeTimers();
            }
        }

        return sandbox;
    }

    sinon.sandbox = sinon.extend(sinon.create(sinon.collection), {
        useFakeTimers: function useFakeTimers() {
            this.clock = sinon.useFakeTimers.apply(sinon, arguments);

            return this.add(this.clock);
        },

        serverPrototype: sinon.fakeServer,

        useFakeServer: function useFakeServer() {
            var proto = this.serverPrototype || sinon.fakeServer;

            if (!proto || !proto.create) {
                return null;
            }

            this.server = proto.create();
            return this.add(this.server);
        },

        inject: function (obj) {
            sinon.collection.inject.call(this, obj);

            if (this.clock) {
                obj.clock = this.clock;
            }

            if (this.server) {
                obj.server = this.server;
                obj.requests = this.server.requests;
            }

            return obj;
        },

        create: function (config) {
            if (!config) {
                return sinon.create(sinon.sandbox);
            }

            var sandbox = prepareSandboxFromConfig(config);
            sandbox.args = sandbox.args || [];
            var prop, value, exposed = sandbox.inject({});

            if (config.properties) {
                for (var i = 0, l = config.properties.length; i < l; i++) {
                    prop = config.properties[i];
                    value = exposed[prop] || prop == "sandbox" && sandbox;
                    exposeValue(sandbox, config, prop, value);
                }
            } else {
                exposeValue(sandbox, config, "sandbox", value);
            }

            return sandbox;
        }
    });

    sinon.sandbox.useFakeXMLHttpRequest = sinon.sandbox.useFakeServer;

    if (typeof module == "object" && typeof require == "function") {
        module.exports = sinon.sandbox;
    }
}());

/**
 * @depend ../sinon.js
 * @depend stub.js
 * @depend mock.js
 * @depend sandbox.js
 */
/*jslint eqeqeq: false, onevar: false, forin: true, plusplus: false*/
/*global module, require, sinon*/
/**
 * Test function, sandboxes fakes
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

(function (sinon) {
    var commonJSModule = typeof module == "object" && typeof require == "function";

    if (!sinon && commonJSModule) {
        sinon = require("../sinon");
    }

    if (!sinon) {
        return;
    }

    function test(callback) {
        var type = typeof callback;

        if (type != "function") {
            throw new TypeError("sinon.test needs to wrap a test function, got " + type);
        }

        return function () {
            var config = sinon.getConfig(sinon.config);
            config.injectInto = config.injectIntoThis && this || config.injectInto;
            var sandbox = sinon.sandbox.create(config);
            var exception, result;
            var args = Array.prototype.slice.call(arguments).concat(sandbox.args);

            try {
                result = callback.apply(this, args);
            } catch (e) {
                exception = e;
            }

            if (typeof exception !== "undefined") {
                sandbox.restore();
                throw exception;
            }
            else {
                sandbox.verifyAndRestore();
            }

            return result;
        };
    }

    test.config = {
        injectIntoThis: true,
        injectInto: null,
        properties: ["spy", "stub", "mock", "clock", "server", "requests"],
        useFakeTimers: true,
        useFakeServer: true
    };

    if (commonJSModule) {
        module.exports = test;
    } else {
        sinon.test = test;
    }
}(typeof sinon == "object" && sinon || null));

/**
 * @depend ../sinon.js
 * @depend test.js
 */
/*jslint eqeqeq: false, onevar: false, eqeqeq: false*/
/*global module, require, sinon*/
/**
 * Test case, sandboxes all test functions
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

(function (sinon) {
    var commonJSModule = typeof module == "object" && typeof require == "function";

    if (!sinon && commonJSModule) {
        sinon = require("../sinon");
    }

    if (!sinon || !Object.prototype.hasOwnProperty) {
        return;
    }

    function createTest(property, setUp, tearDown) {
        return function () {
            if (setUp) {
                setUp.apply(this, arguments);
            }

            var exception, result;

            try {
                result = property.apply(this, arguments);
            } catch (e) {
                exception = e;
            }

            if (tearDown) {
                tearDown.apply(this, arguments);
            }

            if (exception) {
                throw exception;
            }

            return result;
        };
    }

    function testCase(tests, prefix) {
        /*jsl:ignore*/
        if (!tests || typeof tests != "object") {
            throw new TypeError("sinon.testCase needs an object with test functions");
        }
        /*jsl:end*/

        prefix = prefix || "test";
        var rPrefix = new RegExp("^" + prefix);
        var methods = {}, testName, property, method;
        var setUp = tests.setUp;
        var tearDown = tests.tearDown;

        for (testName in tests) {
            if (tests.hasOwnProperty(testName)) {
                property = tests[testName];

                if (/^(setUp|tearDown)$/.test(testName)) {
                    continue;
                }

                if (typeof property == "function" && rPrefix.test(testName)) {
                    method = property;

                    if (setUp || tearDown) {
                        method = createTest(property, setUp, tearDown);
                    }

                    methods[testName] = sinon.test(method);
                } else {
                    methods[testName] = tests[testName];
                }
            }
        }

        return methods;
    }

    if (commonJSModule) {
        module.exports = testCase;
    } else {
        sinon.testCase = testCase;
    }
}(typeof sinon == "object" && sinon || null));

/**
 * @depend ../sinon.js
 * @depend stub.js
 */
/*jslint eqeqeq: false, onevar: false, nomen: false, plusplus: false*/
/*global module, require, sinon*/
/**
 * Assertions matching the test spy retrieval interface.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */

(function (sinon, global) {
    var commonJSModule = typeof module == "object" && typeof require == "function";
    var slice = Array.prototype.slice;
    var assert;

    if (!sinon && commonJSModule) {
        sinon = require("../sinon");
    }

    if (!sinon) {
        return;
    }

    function verifyIsStub() {
        var method;

        for (var i = 0, l = arguments.length; i < l; ++i) {
            method = arguments[i];

            if (!method) {
                assert.fail("fake is not a spy");
            }

            if (typeof method != "function") {
                assert.fail(method + " is not a function");
            }

            if (typeof method.getCall != "function") {
                assert.fail(method + " is not stubbed");
            }
        }
    }

    function failAssertion(object, msg) {
        object = object || global;
        var failMethod = object.fail || assert.fail;
        failMethod.call(object, msg);
    }

    function mirrorPropAsAssertion(name, method, message) {
        if (arguments.length == 2) {
            message = method;
            method = name;
        }

        assert[name] = function (fake) {
            verifyIsStub(fake);

            var args = slice.call(arguments, 1);
            var failed = false;

            if (typeof method == "function") {
                failed = !method(fake);
            } else {
                failed = typeof fake[method] == "function" ?
                    !fake[method].apply(fake, args) : !fake[method];
            }

            if (failed) {
                failAssertion(this, fake.printf.apply(fake, [message].concat(args)));
            } else {
                assert.pass(name);
            }
        };
    }

    function exposedName(prefix, prop) {
        return !prefix || /^fail/.test(prop) ? prop :
            prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1);
    };

    assert = {
        failException: "AssertError",

        fail: function fail(message) {
            var error = new Error(message);
            error.name = this.failException || assert.failException;

            throw error;
        },

        pass: function pass(assertion) {},

        callOrder: function assertCallOrder() {
            verifyIsStub.apply(null, arguments);
            var expected = "", actual = "";

            if (!sinon.calledInOrder(arguments)) {
                try {
                    expected = [].join.call(arguments, ", ");
                    var calls = slice.call(arguments);
                    var i = calls.length;
                    while (i) {
                        if (!calls[--i].called) {
                            calls.splice(i, 1);
                        }
                    }
                    actual = sinon.orderByFirstCall(calls).join(", ");
                } catch (e) {
                    // If this fails, we'll just fall back to the blank string
                }

                failAssertion(this, "expected " + expected + " to be " +
                              "called in order but were called as " + actual);
            } else {
                assert.pass("callOrder");
            }
        },

        callCount: function assertCallCount(method, count) {
            verifyIsStub(method);

            if (method.callCount != count) {
                var msg = "expected %n to be called " + sinon.timesInWords(count) +
                    " but was called %c%C";
                failAssertion(this, method.printf(msg));
            } else {
                assert.pass("callCount");
            }
        },

        expose: function expose(target, options) {
            if (!target) {
                throw new TypeError("target is null or undefined");
            }

            var o = options || {};
            var prefix = typeof o.prefix == "undefined" && "assert" || o.prefix;
            var includeFail = typeof o.includeFail == "undefined" || !!o.includeFail;

            for (var method in this) {
                if (method != "export" && (includeFail || !/^(fail)/.test(method))) {
                    target[exposedName(prefix, method)] = this[method];
                }
            }

            return target;
        }
    };

    mirrorPropAsAssertion("called", "expected %n to have been called at least once but was never called");
    mirrorPropAsAssertion("notCalled", function (spy) { return !spy.called; },
                          "expected %n to not have been called but was called %c%C");
    mirrorPropAsAssertion("calledOnce", "expected %n to be called once but was called %c%C");
    mirrorPropAsAssertion("calledTwice", "expected %n to be called twice but was called %c%C");
    mirrorPropAsAssertion("calledThrice", "expected %n to be called thrice but was called %c%C");
    mirrorPropAsAssertion("calledOn", "expected %n to be called with %1 as this but was called with %t");
    mirrorPropAsAssertion("alwaysCalledOn", "expected %n to always be called with %1 as this but was called with %t");
    mirrorPropAsAssertion("calledWithNew", "expected %n to be called with new");
    mirrorPropAsAssertion("alwaysCalledWithNew", "expected %n to always be called with new");
    mirrorPropAsAssertion("calledWith", "expected %n to be called with arguments %*%C");
    mirrorPropAsAssertion("calledWithMatch", "expected %n to be called with match %*%C");
    mirrorPropAsAssertion("alwaysCalledWith", "expected %n to always be called with arguments %*%C");
    mirrorPropAsAssertion("alwaysCalledWithMatch", "expected %n to always be called with match %*%C");
    mirrorPropAsAssertion("calledWithExactly", "expected %n to be called with exact arguments %*%C");
    mirrorPropAsAssertion("alwaysCalledWithExactly", "expected %n to always be called with exact arguments %*%C");
    mirrorPropAsAssertion("neverCalledWith", "expected %n to never be called with arguments %*%C");
    mirrorPropAsAssertion("neverCalledWithMatch", "expected %n to never be called with match %*%C");
    mirrorPropAsAssertion("threw", "%n did not throw exception%C");
    mirrorPropAsAssertion("alwaysThrew", "%n did not always throw exception%C");

    if (commonJSModule) {
        module.exports = assert;
    } else {
        sinon.assert = assert;
    }
}(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : (typeof self != "undefined") ? self : global));

return sinon;}.call(typeof window != 'undefined' && window || {}));


================================================
FILE: vendors/polyfills/es5.js
================================================
/* reduce implemintation by Mozila https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FArray%2FReduce*/
if ('function' !== typeof Array.prototype.reduce) {
  Array.prototype.reduce = function(callback, opt_initialValue){
    'use strict';
    if (null === this || 'undefined' === typeof this) {
      // At the moment all modern browsers, that support strict mode, have
      // native implementation of Array.prototype.reduce. For instance, IE8
      // does not support strict mode, so this check is actually useless.
      throw new TypeError(
          'Array.prototype.reduce called on null or undefined');
    }
    if ('function' !== typeof callback) {
      throw new TypeError(callback + ' is not a function');
    }
    var index, value,
        length = this.length >>> 0,
        isValueSet = false;
    if (1 < arguments.length) {
      value = opt_initialValue;
      isValueSet = true;
    }
    for (index = 0; length > index; ++index) {
      if (this.hasOwnProperty(index)) {
        if (isValueSet) {
          value = callback(value, this[index], index, this);
        }
        else {
          value = this[index];
          isValueSet = true;
        }
      }
    }
    if (!isValueSet) {
      throw new TypeError('Reduce of empty array with no initial value');
    }
    return value;
  };
}

// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
// Production steps of ECMA-262, Edition 5, 15.4.4.18
// Reference: http://es5.github.com/#x15.4.4.18
if (!Array.prototype.forEach) {

  Array.prototype.forEach = function forEach(callback, thisArg) {
    'use strict';
    var T, k;

    if (this == null) {
      throw new TypeError("this is null or not defined");
    }

    var kValue,
        // 1. Let O be the result of calling ToObject passing the |this| value as the argument.
        O = Object(this),

        // 2. Let lenValue be the result of calling the Get internal method of O with the argument "length".
        // 3. Let len be ToUint32(lenValue).
        len = O.length >>> 0; // Hack to convert O.length to a UInt32

    // 4. If IsCallable(callback) is false, throw a TypeError exception.
    // See: http://es5.github.com/#x9.11
    if ({}.toString.call(callback) !== "[object Function]") {
      throw new TypeError(callback + " is not a function");
    }

    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
    if (arguments.length >= 2) {
      T = thisArg;
    }

    // 6. Let k be 0
    k = 0;

    // 7. Repeat, while k < len
    while (k < len) {

      // a. Let Pk be ToString(k).
      //   This is implicit for LHS operands of the in operator
      // b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk.
      //   This step can be combined with c
      // c. If kPresent is true, then
      if (k in O) {

        // i. Let kValue be the result of calling the Get internal method of O with argument Pk.
        kValue = O[k];

        // ii. Call the Call internal method of callback with T as the this value and
        // argument list containing kValue, k, and O.
        callback.call(T, kValue, k, O);
      }
      // d. Increase k by 1.
      k++;
    }
    // 8. return undefined
  };
}

// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
if (!Object.keys) {
  Object.keys = (function () {
    'use strict';
    var hasOwnProperty = Object.prototype.hasOwnProperty,
        hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
        dontEnums = [
          'toString',
          'toLocaleString',
          'valueOf',
          'hasOwnProperty',
          'isPrototypeOf',
          'propertyIsEnumerable',
          'constructor'
        ],
        dontEnumsLength = dontEnums.length;

    return function (obj) {
      if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
        throw new TypeError('Object.keys called on non-object');
      }

      var result = [], prop, i;

      for (prop in obj) {
        if (hasOwnProperty.call(obj, prop)) {
          result.push(prop);
        }
      }

      if (hasDontEnumBug) {
        for (i = 0; i < dontEnumsLength; i++) {
          if (hasOwnProperty.call(obj, dontEnums[i])) {
            result.push(dontEnums[i]);
          }
        }
      }
      return result;
    };
  }());
}

// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some
if (!Array.prototype.some)
{
  Array.prototype.some = function(fun /*, thisArg */)
  {
    'use strict';

    if (this === void 0 || this === null)
      throw new TypeError();

    var t = Object(this);
    var len = t.length >>> 0;
    if (typeof fun !== 'function')
      throw new TypeError();

    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    for (var i = 0; i < len; i++)
    {
      if (i in t && fun.call(thisArg, t[i], i, t))
        return true;
    }

    return false;
  };
}

// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map
if (!Array.prototype.map)
{
  Array.prototype.map = function(fun /*, thisArg */)
  {
    "use strict";

    if (this === void 0 || this === null)
      throw new TypeError();

    var t = Object(this);
    var len = t.length >>> 0;
    if (typeof fun !== "function")
      throw new TypeError();

    var res = new Array(len);
    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    for (var i = 0; i < len; i++)
    {
      // NOTE: Absolute correctness would demand Object.defineProperty
      //       be used.  But this method is fairly new, and failure is
      //       possible only if Object.prototype or Array.prototype
      //       has a property |i| (very unlikely), so use a less-correct
      //       but more portable alternative.
      if (i in t)
        res[i] = fun.call(thisArg, t[i], i, t);
    }

    return res;
  };
}

//From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
if (!Array.prototype.filter)
{
  Array.prototype.filter = function(fun /*, thisArg */)
  {
    "use strict";

    if (this === void 0 || this === null)
      throw new TypeError();

    var t = Object(this);
    var len = t.length >>> 0;
    if (typeof fun != "function")
      throw new TypeError();

    var res = [];
    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    for (var i = 0; i < len; i++)
    {
      if (i in t)
      {
        var val = t[i];

        // NOTE: Technically this should Object.defineProperty at
        //       the next index, as push can be affected by
        //       properties on Object.prototype and Array.prototype.
        //       But that method's new, and collisions should be
        //       rare, so use the more-compatible alternative.
        if (fun.call(thisArg, val, i, t))
          res.push(val);
      }
    }

    return res;
  };
}

//From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind
if (!Function.prototype.bind) {
  Function.prototype.bind = function (oThis) {
    if (typeof this !== "function") {
      // closest thing possible to the ECMAScript 5 internal IsCallable function
      throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");
    }

    var aArgs = Array.prototype.slice.call(arguments, 1),
        fToBind = this,
        fNOP = function () {},
        fBound = function () {
          return fToBind.apply(this instanceof fNOP && oThis
                                 ? this
                                 : oThis,
                               aArgs.concat(Array.prototype.slice.call(arguments)));
        };

    fNOP.prototype = this.prototype;
    fBound.prototype = new fNOP();

    return fBound;
  };
}

//From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FArray%2FindexOf
if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function (searchElement, fromIndex) {
    if ( this === undefined || this === null ) {
      throw new TypeError( '"this" is null or not defined' );
    }

    var length = this.length >>> 0; // Hack to convert object.length to a UInt32

    fromIndex = +fromIndex || 0;

    if (Math.abs(fromIndex) === Infinity) {
      fromIndex = 0;
    }

    if (fromIndex < 0) {
      fromIndex += length;
      if (fromIndex < 0) {
        fromIndex = 0;
      }
    }

    for (;fromIndex < length; fromIndex++) {
      if (this[fromIndex] === searchElement) {
        return fromIndex;
      }
    }

    return -1;
  };
}


================================================
FILE: vendors/polyfills/promise.js
================================================
if (typeof Promise !== 'function') {
  (function() {
  var define, requireModule, require, requirejs;

  (function() {
    var registry = {}, seen = {};

    define = function(name, deps, callback) {
      registry[name] = { deps: deps, callback: callback };
    };

    requirejs = require = requireModule = function(name) {
    requirejs._eak_seen = registry;

      if (seen[name]) { return seen[name]; }
      seen[name] = {};

      if (!registry[name]) {
        throw new Error("Could not find module " + name);
      }

      var mod = registry[name],
          deps = mod.deps,
          callback = mod.callback,
          reified = [],
          exports;

      for (var i=0, l=deps.length; i<l; i++) {
        if (deps[i] === 'exports') {
          reified.push(exports = {});
        } else {
          reified.push(requireModule(resolve(deps[i])));
        }
      }

      var value = callback.apply(this, reified);
      return seen[name] = exports || value;

      function resolve(child) {
        if (child.charAt(0) !== '.') { return child; }
        var parts = child.split("/");
        var parentBase = name.split("/").slice(0, -1);

        for (var i=0, l=parts.length; i<l; i++) {
          var part = parts[i];

          if (part === '..') { parentBase.pop(); }
          else if (part === '.') { continue; }
          else { parentBase.push(part); }
        }

        return parentBase.join("/");
      }
    };
  })();

  define("promise/all",
    ["./utils","exports"],
    function(__dependency1__, __exports__) {
      "use strict";
      /* global toString */

      var isArray = __dependency1__.isArray;
      var isFunction = __dependency1__.isFunction;

      /**
        Returns a promise that is fulfilled when all the given promises have been
        fulfilled, or rejected if any of them become rejected. The return promise
        is fulfilled with an array that gives all the values in the order they were
        passed in the `promises` array argument.

        Example:

        ```javascript
        var promise1 = RSVP.resolve(1);
        var promise2 = RSVP.resolve(2);
        var promise3 = RSVP.resolve(3);
        var promises = [ promise1, promise2, promise3 ];

        RSVP.all(promises).then(function(array){
          // The array here would be [ 1, 2, 3 ];
        });
        ```

        If any of the `promises` given to `RSVP.all` are rejected, the first promise
        that is rejected will be given as an argument to the returned promises's
        rejection handler. For example:

        Example:

        ```javascript
        var promise1 = RSVP.resolve(1);
        var promise2 = RSVP.reject(new Error("2"));
        var promise3 = RSVP.reject(new Error("3"));
        var promises = [ promise1, promise2, promise3 ];

        RSVP.all(promises).then(function(array){
          // Code here never runs because there are rejected promises!
        }, function(error) {
          // error.message === "2"
        });
        ```

        @method all
        @for RSVP
        @param {Array} promises
        @param {String} label
        @return {Promise} promise that is fulfilled when all `promises` have been
        fulfilled, or rejected if any of them become rejected.
      */
      function all(promises) {
        /*jshint validthis:true */
        var Promise = this;

        if (!isArray(promises)) {
          throw new TypeError('You must pass an array to all.');
        }

        return new Promise(function(resolve, reject) {
          var results = [], remaining = promises.length,
          promise;

          if (remaining === 0) {
            resolve([]);
          }

          function resolver(index) {
            return function(value) {
              resolveAll(index, value);
            };
          }

          function resolveAll(index, value) {
            results[index] = value;
            if (--remaining === 0) {
              resolve(results);
            }
          }

          for (var i = 0; i < promises.length; i++) {
            promise = promises[i];

            if (promise && isFunction(promise.then)) {
              promise.then(resolver(i), reject);
            } else {
              resolveAll(i, promise);
            }
          }
        });
      }

      __exports__.all = all;
    });
  define("promise/asap",
    ["exports"],
    function(__exports__) {
      "use strict";
      var browserGlobal = (typeof window !== 'undefined') ? window : {};
      var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
      var local = window;

      // node
      function useNextTick() {
        return function() {
          process.nextTick(flush);
        };
      }

      function useMutationObserver() {
        var iterations = 0;
        var observer = new BrowserMutationObserver(flush);
        var node = document.createTextNode('');
        observer.observe(node, { characterData: true });

        return function() {
          node.data = (iterations = ++iterations % 2);
        };
      }

      function useSetTimeout() {
        return function() {
          local.setTimeout(flush, 1);
        };
      }

      var queue = [];
      function flush() {
        for (var i = 0; i < queue.length; i++) {
          var tuple = queue[i];
          var callback = tuple[0], arg = tuple[1];
          callback(arg);
        }
        queue = [];
      }

      var scheduleFlush;

      // Decide what async method to use to triggering processing of queued callbacks:
      if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
        scheduleFlush = useNextTick();
      } else if (BrowserMutationObserver) {
        scheduleFlush = useMutationObserver();
      } else {
        scheduleFlush = useSetTimeout();
      }

      function asap(callback, arg) {
        var length = queue.push([callback, arg]);
        if (length === 1) {
          // If length is 1, that means that we need to schedule an async flush.
          // If additional callbacks are queued before the queue is flushed, they
          // will be processed by this flush that we are scheduling.
          scheduleFlush();
        }
      }

      __exports__.asap = asap;
    });
  define("promise/config",
    ["exports"],
    function(__exports__) {
      "use strict";
      var config = {
        instrument: false
      };

      function configure(name, value) {
        if (arguments.length === 2) {
          config[name] = value;
        } else {
          return config[name];
        }
      }

      __exports__.config = config;
      __exports__.configure = configure;
    });
  define("promise/polyfill",
    ["./promise","./utils","exports"],
    function(__dependency1__, __dependency2__, __exports__) {
      "use strict";
      /*global self*/
      var RSVPPromise = __dependency1__.Promise;
      var isFunction = __dependency2__.isFunction;

      function polyfill() {
        var local;

        if (typeof window !== 'undefined' && window.document) {
          local = window;
        } else {
          local = self;
        }

        var es6PromiseSupport =
          "Promise" in local &&
          // Some of these methods are missing from
          // Firefox/Chrome experimental implementations
          "resolve" in local.Promise &&
          "reject" in local.Promise &&
          "all" in local.Promise &&
          "race" in local.Promise &&
          // Older version of the spec had a resolver object
          // as the arg rather than a function
          (function() {
            var resolve;
            new local.Promise(function(r) { resolve = r; });
            return isFunction(resolve);
          }());

        if (!es6PromiseSupport) {
          local.Promise = RSVPPromise;
        }
      }

      __exports__.polyfill = polyfill;
    });
  define("promise/promise",
    ["./config","./utils","./all","./race","./resolve","./reject","./asap","exports"],
    function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
      "use strict";
      var config = __dependency1__.config;
      var configure = __dependency1__.configure;
      var objectOrFunction = __dependency2__.objectOrFunction;
      var isFunction = __dependency2__.isFunction;
      var now = __dependency2__.now;
      var all = __dependency3__.all;
      var race = __dependency4__.race;
      var staticResolve = __dependency5__.resolve;
      var staticReject = __dependency6__.reject;
      var asap = __dependency7__.asap;

      var counter = 0;

      config.async = asap; // default async is asap;

      function Promise(resolver) {
        if (!isFunction(resolver)) {
          throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
        }

        if (!(this instanceof Promise)) {
          throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
        }

        this._subscribers = [];

        invokeResolver(resolver, this);
      }

      function invokeResolver(resolver, promise) {
        function resolvePromise(value) {
          resolve(promise, value);
        }

        function rejectPromise(reason) {
          reject(promise, reason);
        }

        try {
          resolver(resolvePromise, rejectPromise);
        } catch(e) {
          rejectPromise(e);
        }
      }

      function invokeCallback(settled, promise, callback, detail) {
        var hasCallback = isFunction(callback),
            value, error, succeeded, failed;

        if (hasCallback) {
          try {
            value = callback(detail);
            succeeded = true;
          } catch(e) {
            failed = true;
            error = e;
          }
        } else {
          value = detail;
          succeeded = true;
        }

        if (handleThenable(promise, value)) {
          return;
        } else if (hasCallback && succeeded) {
          resolve(promise, value);
        } else if (failed) {
          reject(promise, error);
        } else if (settled === FULFILLED) {
          resolve(promise, value);
        } else if (settled === REJECTED) {
          reject(promise, value);
        }
      }

      var PENDING   = void 0;
      var SEALED    = 0;
      var FULFILLED = 1;
      var REJECTED  = 2;

      function subscribe(parent, child, onFulfillment, onRejection) {
        var subscribers = parent._subscribers;
        var length = subscribers.length;

        subscribers[length] = child;
        subscribers[length + FULFILLED] = onFulfillment;
        subscribers[length + REJECTED]  = onRejection;
      }

      function publish(promise, settled) {
        var child, callback, subscribers = promise._subscribers, detail = promise._detail;

        for (var i = 0; i < subscribers.length; i += 3) {
          child = subscribers[i];
          callback = subscribers[i + settled];

          invokeCallback(settled, child, callback, detail);
        }

        promise._subscribers = null;
      }

      Promise.prototype = {
        constructor: Promise,

        _state: undefined,
        _detail: undefined,
        _subscribers: undefined,

        then: function(onFulfillment, onRejection) {
          var promise = this;

          var thenPromise = new this.constructor(function() {});

          if (this._state) {
            var callbacks = arguments;
            config.async(function invokePromiseCallback() {
              invokeCallback(promise._state, thenPromise, callbacks[promise._state - 1], promise._detail);
            });
          } else {
            subscribe(this, thenPromise, onFulfillment, onRejection);
          }

          return thenPromise;
        },

        'catch': function(onRejection) {
          return this.then(null, onRejection);
        }
      };

      Promise.all = all;
      Promise.race = race;
      Promise.resolve = staticResolve;
      Promise.reject = staticReject;

      function handleThenable(promise, value) {
        var then = null,
        resolved;

        try {
          if (promise === value) {
            throw new TypeError("A promises callback cannot return that same promise.");
          }

          if (objectOrFunction(value)) {
            then = value.then;

            if (isFunction(then)) {
              then.call(value, function(val) {
                if (resolved) { return true; }
                resolved = true;

                if (value !== val) {
                  resolve(promise, val);
                } else {
                  fulfill(promise, val);
                }
              }, function(val) {
                if (resolved) { return true; }
                resolved = true;

                reject(promise, val);
              });

              return true;
            }
          }
        } catch (error) {
          if (resolved) { return true; }
          reject(promise, error);
          return true;
        }

        return false;
      }

      function resolve(promise, value) {
        if (promise === value) {
          fulfill(promise, value);
        } else if (!handleThenable(promise, value)) {
          fulfill(promise, value);
        }
      }

      function fulfill(promise, value) {
        if (promise._state !== PENDING) { return; }
        promise._state = SEALED;
        promise._detail = value;

        config.async(publishFulfillment, promise);
      }

      function reject(promise, reason) {
        if (promise._state !== PENDING) { return; }
        promise._state = SEALED;
        promise._detail = reason;

        config.async(publishRejection, promise);
      }

      function publishFulfillment(promise) {
        publish(promise, promise._state = FULFILLED);
      }

      function publishRejection(promise) {
        publish(promise, promise._state = REJECTED);
      }

      __exports__.Promise = Promise;
    });
  define("promise/race",
    ["./utils","exports"],
    function(__dependency1__, __exports__) {
      "use strict";
      /* global toString */
      var isArray = __dependency1__.isArray;

      /**
        `RSVP.race` allows you to watch a series of promises and act as soon as the
        first promise given to the `promises` argument fulfills or rejects.

        Example:

        ```javascript
        var promise1 = new RSVP.Promise(function(resolve, reject){
          setTimeout(function(){
            resolve("promise 1");
          }, 200);
        });

        var promise2 = new RSVP.Promise(function(resolve, reject){
          setTimeout(function(){
            resolve("promise 2");
          }, 100);
        });

        RSVP.race([promise1, promise2]).then(function(result){
          // result === "promise 2" because it was resolved before promise1
          // was resolved.
        });
        ```

        `RSVP.race` is deterministic in that only the state of the first completed
        promise matters. For example, even if other promises given to the `promises`
        array argument are resolved, but the first completed promise has become
        rejected before the other promises became fulfilled, the returned promise
        will become rejected:

        ```javascript
        var promise1 = new RSVP.Promise(function(resolve, reject){
          setTimeout(function(){
            resolve("promise 1");
          }, 200);
        });

        var promise2 = new RSVP.Promise(function(resolve, reject){
          setTimeout(function(){
            reject(new Error("promise 2"));
          }, 100);
        });

        RSVP.race([promise1, promise2]).then(function(result){
          // Code here never runs because there are rejected promises!
        }, function(reason){
          // reason.message === "promise2" because promise 2 became rejected before
          // promise 1 became fulfilled
        });
        ```

        @method race
        @for RSVP
        @param {Array} promises array of promises to observe
        @param {String} label optional string for describing the promise returned.
        Useful for tooling.
        @return {Promise} a promise that becomes fulfilled with the value the first
        completed promises is resolved with if the first completed promise was
        fulfilled, or rejected with the reason that the first completed promise
        was rejected with.
      */
      function race(promises) {
        /*jshint validthis:true */
        var Promise = this;

        if (!isArray(promises)) {
          throw new TypeError('You must pass an array to race.');
        }
        return new Promise(function(resolve, reject) {
          var results = [], promise;

          for (var i = 0; i < promises.length; i++) {
            promise = promises[i];

            if (promise && typeof promise.then === 'function') {
              promise.then(resolve, reject);
            } else {
              resolve(promise);
            }
          }
        });
      }

      __exports__.race = race;
    });
  define("promise/reject",
    ["exports"],
    function(__exports__) {
      "use strict";
      /**
        `RSVP.reject` returns a promise that will become rejected with the passed
        `reason`. `RSVP.reject` is essentially shorthand for the following:

        ```javascript
        var promise = new RSVP.Promise(function(resolve, reject){
          reject(new Error('WHOOPS'));
        });

        promise.then(function(value){
          // Code here doesn't run because the promise is rejected!
        }, function(reason){
          // reason.message === 'WHOOPS'
        });
        ```

        Instead of writing the above, your code now simply becomes the following:

        ```javascript
        var promise = RSVP.reject(new Error('WHOOPS'));

        promise.then(function(value){
          // Code here doesn't run because the promise is rejected!
        }, function(reason){
          // reason.message === 'WHOOPS'
        });
        ```

        @method reject
        @for RSVP
        @param {Any} reason value that the returned promise will be rejected with.
        @param {String} label optional string for identifying the returned promise.
        Useful for tooling.
        @return {Promise} a promise that will become rejected with the given
        `reason`.
      */
      function reject(reason) {
        /*jshint validthis:true */
        var Promise = this;

        return new Promise(function (resolve, reject) {
          reject(reason);
        });
      }

      __exports__.reject = reject;
    });
  define("promise/resolve",
    ["exports"],
    function(__exports__) {
      "use strict";
      function resolve(value) {
        /*jshint validthis:true */
        if (value && typeof value === 'object' && value.constructor === this) {
          return value;
        }

        var Promise = this;

        return new Promise(function(resolve) {
          resolve(value);
        });
      }

      __exports__.resolve = resolve;
    });
  define("promise/utils",
    ["exports"],
    function(__exports__) {
      "use strict";
      function objectOrFunction(x) {
        return isFunction(x) || (typeof x === "object" && x !== null);
      }

      function isFunction(x) {
        return typeof x === "function";
      }

      function isArray(x) {
        return Object.prototype.toString.call(x) === "[object Array]";
      }

      // Date.now is not available in browsers < IE9
      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now#Compatibility
      var now = Date.now || function() { return new Date().getTime(); };


      __exports__.objectOrFunction = objectOrFunction;
      __exports__.isFunction = isFunction;
      __exports__.isArray = isArray;
      __exports__.now = now;
    });
  requireModule('promise/polyfill').polyfill();
  }());
}