From 5e25748d83f3cce5bc60bf36c63499eaefe80c29 Mon Sep 17 00:00:00 2001
From: Alexandre Archambault <alexandre.archambault@gmail.com>
Date: Tue, 16 Jun 2015 20:17:07 +0200
Subject: [PATCH] Initial commit

---
 .gitignore                                    |    1 +
 .idea/uiDesigner.xml                          |  124 +
 .travis.yml                                   |   11 +
 README.md                                     |   22 +
 USAGE.md                                      |   43 +
 cli/src/main/resources/logback.xml            |   27 +
 .../main/scala/coursier/cli/Coursier.scala    |  143 +
 .../src/main/scala/coursier/core/Remote.scala |  107 +
 .../core/compatibility/DateTime.scala         |  263 +
 .../coursier/core/compatibility/package.scala |   71 +
 .../scala/coursier/repository/package.scala   |   13 +
 .../scala/scalaz/concurrent/package.scala     |   42 +
 .../test/scala/coursier/test/JsTests.scala    |   41 +
 .../coursier/test/compatibility/package.scala |    7 +
 .../src/main/scala/coursier/core/Remote.scala |  229 +
 .../coursier/core/compatibility/package.scala |   34 +
 .../main/scala/coursier/core/package.scala    |   31 +
 .../scala/coursier/repository/package.scala   |   15 +
 .../coursier/test/compatibility/package.scala |   14 +
 .../coursier/core/ComparableVersion.scala     |  205 +
 .../scala/coursier/core/Definitions.scala     |   47 +
 core/src/main/scala/coursier/core/Parse.scala |   43 +
 .../main/scala/coursier/core/Repository.scala |   38 +
 .../main/scala/coursier/core/Resolver.scala   |  717 ++
 .../main/scala/coursier/core/Version.scala    |  104 +
 core/src/main/scala/coursier/core/Xml.scala   |  247 +
 core/src/main/scala/coursier/package.scala    |   79 +
 .../scala/coursier/test/CentralTests.scala    |   42 +
 .../test/ComparableVersionTests.scala         |  343 +
 .../scala/coursier/test/ExclusionsTests.scala |  124 +
 .../scala/coursier/test/PomParsingTests.scala |  143 +
 .../scala/coursier/test/ResolverTests.scala   |  464 +
 .../scala/coursier/test/TestRepository.scala  |   19 +
 .../test/VersionConstraintTests.scala         |   56 +
 .../coursier/test/VersionIntervalTests.scala  |  318 +
 .../test/scala/coursier/test/package.scala    |    9 +
 project/Coursier.scala                        |  121 +
 project/build.properties                      |    1 +
 project/plugins.sbt                           |    7 +
 project/travis.sh                             |   40 +
 version.sbt                                   |    1 +
 .../main/resources/css/bootstrap-treeview.css |   37 +
 web/src/main/resources/index-dev.html         |  143 +
 web/src/main/resources/index-opt.html         |   18 +
 .../main/resources/js/bootstrap-treeview.js   | 1249 +++
 web/src/main/resources/js/dracula_graffle.js  |  128 +
 web/src/main/resources/js/dracula_graph.js    |  685 ++
 web/src/main/resources/js/raphael.js          | 8117 +++++++++++++++++
 web/src/main/resources/js/routie.min.js       |    8 +
 web/src/main/scala/coursier/web/Backend.scala |  535 ++
 web/src/main/scala/coursier/web/Main.scala    |   13 +
 51 files changed, 15339 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 .idea/uiDesigner.xml
 create mode 100644 .travis.yml
 create mode 100644 README.md
 create mode 100644 USAGE.md
 create mode 100644 cli/src/main/resources/logback.xml
 create mode 100644 cli/src/main/scala/coursier/cli/Coursier.scala
 create mode 100644 core-js/src/main/scala/coursier/core/Remote.scala
 create mode 100644 core-js/src/main/scala/coursier/core/compatibility/DateTime.scala
 create mode 100644 core-js/src/main/scala/coursier/core/compatibility/package.scala
 create mode 100644 core-js/src/main/scala/coursier/repository/package.scala
 create mode 100644 core-js/src/main/scala/scalaz/concurrent/package.scala
 create mode 100644 core-js/src/test/scala/coursier/test/JsTests.scala
 create mode 100644 core-js/src/test/scala/coursier/test/compatibility/package.scala
 create mode 100644 core-jvm/src/main/scala/coursier/core/Remote.scala
 create mode 100644 core-jvm/src/main/scala/coursier/core/compatibility/package.scala
 create mode 100644 core-jvm/src/main/scala/coursier/core/package.scala
 create mode 100644 core-jvm/src/main/scala/coursier/repository/package.scala
 create mode 100644 core-jvm/src/test/scala/coursier/test/compatibility/package.scala
 create mode 100644 core/src/main/scala/coursier/core/ComparableVersion.scala
 create mode 100644 core/src/main/scala/coursier/core/Definitions.scala
 create mode 100644 core/src/main/scala/coursier/core/Parse.scala
 create mode 100644 core/src/main/scala/coursier/core/Repository.scala
 create mode 100644 core/src/main/scala/coursier/core/Resolver.scala
 create mode 100644 core/src/main/scala/coursier/core/Version.scala
 create mode 100644 core/src/main/scala/coursier/core/Xml.scala
 create mode 100644 core/src/main/scala/coursier/package.scala
 create mode 100644 core/src/test/scala/coursier/test/CentralTests.scala
 create mode 100644 core/src/test/scala/coursier/test/ComparableVersionTests.scala
 create mode 100644 core/src/test/scala/coursier/test/ExclusionsTests.scala
 create mode 100644 core/src/test/scala/coursier/test/PomParsingTests.scala
 create mode 100644 core/src/test/scala/coursier/test/ResolverTests.scala
 create mode 100644 core/src/test/scala/coursier/test/TestRepository.scala
 create mode 100644 core/src/test/scala/coursier/test/VersionConstraintTests.scala
 create mode 100644 core/src/test/scala/coursier/test/VersionIntervalTests.scala
 create mode 100644 core/src/test/scala/coursier/test/package.scala
 create mode 100644 project/Coursier.scala
 create mode 100644 project/build.properties
 create mode 100644 project/plugins.sbt
 create mode 100755 project/travis.sh
 create mode 100644 version.sbt
 create mode 100644 web/src/main/resources/css/bootstrap-treeview.css
 create mode 100644 web/src/main/resources/index-dev.html
 create mode 100644 web/src/main/resources/index-opt.html
 create mode 100644 web/src/main/resources/js/bootstrap-treeview.js
 create mode 100644 web/src/main/resources/js/dracula_graffle.js
 create mode 100644 web/src/main/resources/js/dracula_graph.js
 create mode 100644 web/src/main/resources/js/raphael.js
 create mode 100644 web/src/main/resources/js/routie.min.js
 create mode 100644 web/src/main/scala/coursier/web/Backend.scala
 create mode 100644 web/src/main/scala/coursier/web/Main.scala

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 000000000..2f7896d1d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+target/
diff --git a/.idea/uiDesigner.xml b/.idea/uiDesigner.xml
new file mode 100644
index 000000000..e96534fb2
--- /dev/null
+++ b/.idea/uiDesigner.xml
@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Palette2">
+    <group name="Swing">
+      <item class="com.intellij.uiDesigner.HSpacer" tooltip-text="Horizontal Spacer" icon="/com/intellij/uiDesigner/icons/hspacer.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="1" hsize-policy="6" anchor="0" fill="1" />
+      </item>
+      <item class="com.intellij.uiDesigner.VSpacer" tooltip-text="Vertical Spacer" icon="/com/intellij/uiDesigner/icons/vspacer.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="1" anchor="0" fill="2" />
+      </item>
+      <item class="javax.swing.JPanel" icon="/com/intellij/uiDesigner/icons/panel.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3" />
+      </item>
+      <item class="javax.swing.JScrollPane" icon="/com/intellij/uiDesigner/icons/scrollPane.png" removable="false" auto-create-binding="false" can-attach-label="true">
+        <default-constraints vsize-policy="7" hsize-policy="7" anchor="0" fill="3" />
+      </item>
+      <item class="javax.swing.JButton" icon="/com/intellij/uiDesigner/icons/button.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="3" anchor="0" fill="1" />
+        <initial-values>
+          <property name="text" value="Button" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JRadioButton" icon="/com/intellij/uiDesigner/icons/radioButton.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
+        <initial-values>
+          <property name="text" value="RadioButton" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JCheckBox" icon="/com/intellij/uiDesigner/icons/checkBox.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
+        <initial-values>
+          <property name="text" value="CheckBox" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JLabel" icon="/com/intellij/uiDesigner/icons/label.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="0" anchor="8" fill="0" />
+        <initial-values>
+          <property name="text" value="Label" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JTextField" icon="/com/intellij/uiDesigner/icons/textField.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <preferred-size width="150" height="-1" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JPasswordField" icon="/com/intellij/uiDesigner/icons/passwordField.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <preferred-size width="150" height="-1" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JFormattedTextField" icon="/com/intellij/uiDesigner/icons/formattedTextField.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <preferred-size width="150" height="-1" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTextArea" icon="/com/intellij/uiDesigner/icons/textArea.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTextPane" icon="/com/intellij/uiDesigner/icons/textPane.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JEditorPane" icon="/com/intellij/uiDesigner/icons/editorPane.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JComboBox" icon="/com/intellij/uiDesigner/icons/comboBox.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="2" anchor="8" fill="1" />
+      </item>
+      <item class="javax.swing.JTable" icon="/com/intellij/uiDesigner/icons/table.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JList" icon="/com/intellij/uiDesigner/icons/list.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="2" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTree" icon="/com/intellij/uiDesigner/icons/tree.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTabbedPane" icon="/com/intellij/uiDesigner/icons/tabbedPane.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
+          <preferred-size width="200" height="200" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JSplitPane" icon="/com/intellij/uiDesigner/icons/splitPane.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
+          <preferred-size width="200" height="200" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JSpinner" icon="/com/intellij/uiDesigner/icons/spinner.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
+      </item>
+      <item class="javax.swing.JSlider" icon="/com/intellij/uiDesigner/icons/slider.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
+      </item>
+      <item class="javax.swing.JSeparator" icon="/com/intellij/uiDesigner/icons/separator.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3" />
+      </item>
+      <item class="javax.swing.JProgressBar" icon="/com/intellij/uiDesigner/icons/progressbar.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1" />
+      </item>
+      <item class="javax.swing.JToolBar" icon="/com/intellij/uiDesigner/icons/toolbar.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1">
+          <preferred-size width="-1" height="20" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JToolBar$Separator" icon="/com/intellij/uiDesigner/icons/toolbarSeparator.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="0" anchor="0" fill="1" />
+      </item>
+      <item class="javax.swing.JScrollBar" icon="/com/intellij/uiDesigner/icons/scrollbar.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="0" anchor="0" fill="2" />
+      </item>
+    </group>
+  </component>
+</project>
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 000000000..b7445dc9f
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,11 @@
+language: scala
+scala:
+- 2.11.6
+- 2.10.5
+jdk:
+- oraclejdk7
+- oraclejdk8
+install:
+- npm install xmldom
+- npm install xhr2
+script: project/travis.sh "$TRAVIS_SCALA_VERSION" "$TRAVIS_PULL_REQUEST" "$TRAVIS_BRANCH"
diff --git a/README.md b/README.md
new file mode 100644
index 000000000..0fbe434f8
--- /dev/null
+++ b/README.md
@@ -0,0 +1,22 @@
+# Coursier
+
+*Pure Scala Artifact Fetching*
+
+A pure Scala substitute for [Aether](http://www.eclipse.org/aether/)
+
+Work in progress:
+* full list of dependencies / version conflict resolution working, mildly to well tested,
+* downloading/caching of JARs in its early stages.
+
+Implements fancy Maven features like
+* [POM inheritance](http://books.sonatype.com/mvnref-book/reference/pom-relationships-sect-project-relationships.html#pom-relationships-sect-project-inheritance),
+* [dependency management](http://books.sonatype.com/mvnex-book/reference/optimizing-sect-dependencies.html),
+* [import scope](https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html#Importing_Dependencies),
+* [properties](http://books.sonatype.com/mvnref-book/reference/resource-filtering-sect-properties.html).
+
+Restricted to Maven resolution and repositories for now. Support for Ivy seems definitely at reach, just not done yet.
+
+Both a JVM library and a Scala JS one.
+
+
+Released under the Apache license, v2.
diff --git a/USAGE.md b/USAGE.md
new file mode 100644
index 000000000..905393705
--- /dev/null
+++ b/USAGE.md
@@ -0,0 +1,43 @@
+# API
+
+Ensure you have a dependency on its artifact, e.g. add in `build.sbt`,
+```scala
+resolvers += Resolver.sonatypeRepo("snapshots")
+
+libraryDependencies +=
+  "eu.frowning-lambda" %% "coursier" % "0.1.0-SNAPSHOT"
+```
+
+Then,
+```scala
+import coursier._
+val repositories = Seq(
+  repository.mavenCentral
+)
+
+val dependencies = Set(
+  Dependency(Module("com.lihaoyi", "ammonite-pprint_2.11", "0.3.2")),
+  Dependency(Module("org.scala-lang", "scala-reflect", "2.11.6"))
+)
+
+
+val resolution =
+  resolve(dependencies, fetchFrom(repositories)).run
+
+assert(resolution.isDone) // Check that resolution converged
+
+// Printing the results
+for (dep <- resolution.dependencies if resolution.projectsCache.contains(dep.module))
+  println(resolution.projectsCache(dep.module))
+for (dep <- resolution.dependencies if resolution.errors.contains(dep.module))
+  println(resolution.errors(dep.module))
+
+import coursier.core.ArtifactDownloader
+
+val dl = ArtifactDownloader(repository.mavenCentral.root, new java.io.File("cache"))
+for (dep <- resolution.dependencies if resolution.projectsCache.contains(dep.module))
+  dl.artifact(dep).run.run match {
+    case -\/(err) => println(s"Failed to download ${dep.module}: $err")
+    case \/-(file) => println(s"${dep.module}: $file")
+  }
+```
diff --git a/cli/src/main/resources/logback.xml b/cli/src/main/resources/logback.xml
new file mode 100644
index 000000000..6caaa5f21
--- /dev/null
+++ b/cli/src/main/resources/logback.xml
@@ -0,0 +1,27 @@
+<configuration>
+  <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <file>${java.io.tmpdir}/coursier.log</file>
+      <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
+          <fileNamePattern>${java.io.tmpdir}/coursier.%i.log.zip</fileNamePattern>
+          <minIndex>1</minIndex>
+          <maxIndex>3</maxIndex>
+      </rollingPolicy>
+
+      <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
+          <maxFileSize>5MB</maxFileSize>
+      </triggeringPolicy>
+    <encoder>
+      <pattern>%date{YYYY-MM-dd HH:mm:ss} %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <encoder>
+      <pattern>%msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <root level="debug">
+    <appender-ref ref="FILE" />
+  </root>
+</configuration>
diff --git a/cli/src/main/scala/coursier/cli/Coursier.scala b/cli/src/main/scala/coursier/cli/Coursier.scala
new file mode 100644
index 000000000..77b0c60c5
--- /dev/null
+++ b/cli/src/main/scala/coursier/cli/Coursier.scala
@@ -0,0 +1,143 @@
+package coursier
+package cli
+
+import java.io.File
+
+import caseapp._
+import coursier.core.{CachePolicy, Parse}
+import coursier.core.{ArtifactDownloaderLogger, RemoteLogger, ArtifactDownloader}
+
+import scalaz.concurrent.Task
+import scalaz.{-\/, \/-}
+
+case class Coursier(scope: List[String],
+                    keepOptional: Boolean,
+                    fetch: Boolean) extends App {
+
+  val scopes0 =
+    if (scope.isEmpty) List(Scope.Compile, Scope.Runtime)
+    else scope.map(Parse.scope)
+  val scopes = scopes0.toSet
+
+  val centralCacheDir = new File(sys.props("user.home") + "/.coursier/cache/central")
+
+  val base = centralCacheDir.toURI
+  def fileRepr(f: File) =
+    base.relativize(f.toURI).getPath
+
+  val logger: RemoteLogger with ArtifactDownloaderLogger = new RemoteLogger with ArtifactDownloaderLogger {
+    def downloading(url: String) =
+      println(s"Downloading $url")
+    def downloaded(url: String, success: Boolean) =
+      println(
+        if (success) s"Downloaded $url"
+        else s"Failed to download $url"
+      )
+    def readingFromCache(f: File) = {
+      println(s"Reading ${fileRepr(f)} from cache")
+    }
+    def puttingInCache(f: File) =
+      println(s"Writing ${fileRepr(f)} in cache")
+
+    def foundLocally(f: File) =
+      println(s"Found locally ${fileRepr(f)}")
+    def downloadingArtifact(url: String) =
+      println(s"Downloading $url")
+    def downloadedArtifact(url: String, success: Boolean) =
+      println(
+        if (success) s"Downloaded $url"
+        else s"Failed to download $url"
+      )
+  }
+
+  val cachedMavenCentral = repository.mavenCentral.copy(cache = Some(centralCacheDir), logger = Some(logger))
+  val repositories = Seq[Repository](
+    cachedMavenCentral
+  )
+
+  lazy val downloaders = Map[Repository, ArtifactDownloader](
+    cachedMavenCentral -> ArtifactDownloader(repository.mavenCentral.root, centralCacheDir, logger = Some(logger))
+  )
+
+  val (splitArtifacts, malformed) = remainingArgs.toList
+    .map(_.split(":", 3).toSeq)
+    .partition(_.length == 3)
+
+  if (splitArtifacts.isEmpty) {
+    Console.err.println("Usage: coursier artifacts...")
+    sys exit 1
+  }
+
+  if (malformed.nonEmpty) {
+    Console.err.println(s"Malformed artifacts:\n${malformed.map(_.mkString(":")).mkString("\n")}")
+    sys exit 1
+  }
+
+  val modules = splitArtifacts.map{
+    case Seq(org, name, version) =>
+      Module(org, name, version)
+  }
+
+  val deps = modules.map(mod =>
+    Dependency(mod, scope = Scope.Runtime)
+  )
+
+  val res = resolve(
+    deps.toSet,
+    fetchFrom(repositories),
+    filter = Some(dep => (keepOptional || !dep.optional) && scopes(dep.scope))
+  ).run
+
+  def repr(dep: Dependency) =
+    s"${dep.module.organization}:${dep.module.name}:${dep.`type`}:${Some(dep.classifier).filter(_.nonEmpty).map(_+":").mkString}${dep.module.version}"
+
+  val trDeps = res.dependencies.toList.map(repr).sorted
+
+  println("\n" + trDeps.mkString("\n"))
+
+  if (fetch) {
+    println()
+
+    val cachePolicy: CachePolicy = CachePolicy.Default
+
+    val m = res.dependencies.groupBy(dep => res.projectsCache.get(dep.module).map(_._1))
+    val (notFound, remaining0) = m.partition(_._1.isEmpty)
+    if (notFound.nonEmpty) {
+      val notFound0 = notFound.values.flatten.toList.map(repr).sorted
+      println(s"Not found:${notFound0.mkString("\n")}")
+    }
+
+    val (remaining, downloaderNotFound) = remaining0.partition(t => downloaders.contains(t._1.get))
+    if (downloaderNotFound.nonEmpty) {
+      val downloaderNotFound0 = downloaderNotFound.values.flatten.toList.map(repr).sorted
+      println(s"Don't know how to download:${downloaderNotFound0.mkString("\n")}")
+    }
+
+    val sorted = remaining
+      .toList
+      .map{ case (Some(repo), deps) => repo -> deps.toList.sortBy(repr) }
+      .sortBy(_._1.toString) // ...
+
+    val tasks =
+      for {
+        (repo, deps) <- sorted
+        dl = downloaders(repo)
+        dep <- deps
+      } yield {
+        dl.artifact(dep, cachePolicy = cachePolicy).run.map {
+          case -\/(err) =>
+            println(s"Failed to get ${repr(dep)}: $err")
+          case \/-(f) =>
+            println(s"${repr(dep)}:\n  ${fileRepr(f)}")
+        }
+      }
+
+    val task = Task.gatherUnordered(tasks)
+
+    task.run
+  }
+}
+
+object Coursier extends AppOf[Coursier] {
+  val parser = default
+}
diff --git a/core-js/src/main/scala/coursier/core/Remote.scala b/core-js/src/main/scala/coursier/core/Remote.scala
new file mode 100644
index 000000000..3963d5789
--- /dev/null
+++ b/core-js/src/main/scala/coursier/core/Remote.scala
@@ -0,0 +1,107 @@
+package coursier
+package core
+
+import org.scalajs.dom.raw.{Event, XMLHttpRequest}
+
+import scala.concurrent.{ExecutionContext, Promise, Future}
+import scalaz.{-\/, \/-, \/, EitherT}
+import scalaz.concurrent.Task
+
+import scala.scalajs.js
+import js.Dynamic.{global => g}
+
+object Remote {
+
+  def encodeURIComponent(s: String): String =
+    g.encodeURIComponent(s).asInstanceOf[String]
+
+  lazy val jsonpAvailable = js.isUndefined(g.jsonp)
+
+  def proxiedJsonp(url: String)(implicit executionContext: ExecutionContext): Future[String] =
+    if (url.contains("{")) Future.successful("") // jsonp callback never gets executed in this case (empty response)
+    else {
+
+    // FIXME url is put between quotes in the YQL query, which could sometimes require some extra encoding
+    val url0 =
+      "https://query.yahooapis.com/v1/public/yql?q=select%20*%20from%20xml%20where%20url%3D%22" +
+        encodeURIComponent(url) +
+        "%22&format=jsonp&diagnostics=true"
+
+    val p = Promise[String]()
+
+    // FIXME Promise may not be always completed in case of failure
+
+    g.jsonp(url0, (res: js.Dynamic) => {
+      val success = !js.isUndefined(res) && !js.isUndefined(res.results)
+      if (success)
+        p.success(res.results.asInstanceOf[js.Array[String]].mkString("\n"))
+      else
+        p.failure(new Exception(s"Fetching $url ($url0)"))
+    })
+
+    p.future
+  }
+
+  def get(url: String)(implicit executionContext: ExecutionContext): Future[Either[String, Xml.Node]] =
+    if (jsonpAvailable) {
+      // Assume we're running on node, and that node package xhr2 is installed
+      val xhr = g.require("xhr2")
+
+      val p = Promise[Either[String, Xml.Node]]()
+      val req = js.Dynamic.newInstance(xhr)().asInstanceOf[XMLHttpRequest]
+      val f = { _: Event =>
+        p.success(compatibility.xmlParse(req.responseText))
+      }
+      req.onload = f
+
+      req.open("GET", url)
+      req.send()
+
+      p.future
+    } else {
+      proxiedJsonp(url).map(compatibility.xmlParse)
+    }
+
+}
+
+trait Logger {
+  def fetching(url: String): Unit
+  def fetched(url: String): Unit
+  def other(url: String, msg: String): Unit
+}
+
+case class Remote(base: String, logger: Option[Logger] = None) extends Repository {
+
+  def find(module: Module,
+           cachePolicy: CachePolicy): EitherT[Task, String, Project] = {
+
+    val relPath =
+      module.organization.split('.').toSeq ++ Seq(
+        module.name,
+        module.version,
+        s"${module.name}-${module.version}.pom"
+      )
+
+    val url = base + relPath.mkString("/")
+
+    EitherT(Task{ implicit ec =>
+      logger.foreach(_.fetching(url))
+      Remote.get(url).map{ eitherXml =>
+        logger.foreach(_.fetched(url))
+        for {
+          xml <- \/.fromEither(eitherXml)
+          _ = logger.foreach(_.other(url, "is XML"))
+          _ <- if (xml.label == "project") \/-(()) else -\/("Project definition not found")
+          _ = logger.foreach(_.other(url, "project definition found"))
+          proj <- Xml.project(xml)
+          _ = logger.foreach(_.other(url, "project definition ok"))
+        } yield proj
+      }
+    })
+  }
+
+  def versions(organization: String,
+               name: String,
+               cachePolicy: CachePolicy): EitherT[Task, String, Versions] = ???
+
+}
diff --git a/core-js/src/main/scala/coursier/core/compatibility/DateTime.scala b/core-js/src/main/scala/coursier/core/compatibility/DateTime.scala
new file mode 100644
index 000000000..9b7e727aa
--- /dev/null
+++ b/core-js/src/main/scala/coursier/core/compatibility/DateTime.scala
@@ -0,0 +1,263 @@
+package coursier.core.compatibility
+
+// Cut-n-pasted from http4s 0.7.0
+// Replaced Writer usages with StringBuilder
+
+final class DateTime private (val year: Int, // the year
+                              val month: Int, // the month of the year. January is 1.
+                              val day: Int, // the day of the month. The first day is 1.
+                              val hour: Int, // the hour of the day. The first hour is 0.
+                              val minute: Int, // the minute of the hour. The first minute is 0.
+                              val second: Int, // the second of the minute. The first second is 0.
+                              val weekday: Int, // the day of the week. Sunday is 0.
+                              val clicks: Long) // milliseconds since January 1, 1970, 00:00:00 GMT
+  extends Ordered[DateTime] with Product6[Int, Int, Int, Int, Int, Int] {
+  import DateTime.StringBuilderExtensions
+
+  /**
+   * The day of the week as a 3 letter abbreviation:
+   * `Sun`, `Mon`, `Tue`, `Wed`, `Thu`, `Fri` or `Sat`
+   */
+  def weekdayStr: String = DateTime.WEEKDAYS(weekday)
+
+  /**
+   * The day of the month as a 3 letter abbreviation:
+   * `Jan`, `Feb`, `Mar`, `Apr`, `May`, `Jun`, `Jul`, `Aug`, `Sep`, `Oct`, `Nov` or `Dec`
+   */
+  def monthStr: String = DateTime.MONTHS(month - 1)
+
+  /**
+   * Creates a new `DateTime` that represents the point in time the given number of ms later.
+   */
+  def +(millis: Long): DateTime = DateTime(clicks + millis)
+
+  /**
+   * Creates a new `DateTime` that represents the point in time the given number of ms earlier.
+   */
+  def -(millis: Long): DateTime = DateTime(clicks - millis)
+
+  /**
+   * `yyyy-mm-ddThh:mm:ss`
+   */
+  override def toString = toIsoDateTimeString
+
+  /**
+   * `yyyy-mm-dd`
+   */
+  def renderIsoDate(w: StringBuilder): w.type = {
+    put_##(put_##(w << year << '-', month) << '-', day)
+    w
+  }
+
+  /**
+   * `yyyy-mm-dd`
+   */
+  def toIsoDateString = { val w = new StringBuilder; renderIsoDate(w).result() }
+
+  /**
+   * `yyyy-mm-ddThh:mm:ss`
+   */
+  def renderIsoDateTimeString(w: StringBuilder): w.type = {
+    put_##(put_##(put_##(renderIsoDate(w) << 'T', hour) << ':', minute) << ':', second)
+    w
+  }
+
+  /**
+   * `yyyy-mm-ddThh:mm:ss`
+   */
+  def toIsoDateTimeString = { val w = new StringBuilder; renderIsoDateTimeString(w).result() }
+
+  /**
+   * `yyyy-mm-dd hh:mm:ss`
+   */
+  def renderIsoLikeDateTimeString(w: StringBuilder): w.type = {
+    put_##(put_##(put_##(renderIsoDate(w) << ' ', hour) << ':', minute) << ':', second)
+    w
+  }
+
+  /**
+   * `yyyy-mm-dd hh:mm:ss`
+   */
+  def toIsoLikeDateTimeString = { val w = new StringBuilder; renderIsoLikeDateTimeString(w).result() }
+
+  /**
+   * RFC1123 date string, e.g. `Sun, 06 Nov 1994 08:49:37 GMT`
+   */
+  def renderRfc1123DateTimeString(w: StringBuilder): w.type = {
+    w ++= weekdayStr
+    w ++= ", "
+    put_##(put_##(put_##(put_##(w << weekdayStr << ',' << ' ', day) << ' ' << monthStr << ' ' << year << ' ', hour) << ':', minute) << ':', second) << " GMT"
+    w
+  }
+
+  /**
+   * RFC1123 date string, e.g. `Sun, 06 Nov 1994 08:49:37 GMT`
+   */
+  def toRfc1123DateTimeString = { val w = new StringBuilder; renderRfc1123DateTimeString(w).result() }
+
+  private def put_##(w: StringBuilder, i: Int): w.type = {
+    w << (i / 10 + '0').toChar << (i % 10 + '0').toChar
+    w
+  }
+
+  def compare(that: DateTime): Int = math.signum(clicks - that.clicks).toInt
+
+  override def hashCode() = clicks.##
+
+  override def equals(obj: Any) = obj match {
+    case x: DateTime ⇒ x.clicks == clicks
+    case _           ⇒ false
+  }
+
+  override def _1: Int = year
+  override def _2: Int = month
+  override def _3: Int = day
+  override def _4: Int = hour
+  override def _5: Int = minute
+  override def _6: Int = second
+
+  override def canEqual(that: Any): Boolean = that.isInstanceOf[DateTime]
+}
+
+object DateTime {
+
+  private implicit class StringBuilderExtensions(val b: StringBuilder) extends AnyVal {
+    def <<(s: String): b.type = b ++= s
+    def <<(c: Char): b.type = b += c
+    def <<(n: Int): b.type = b ++= n.toString
+  }
+
+  val WEEKDAYS = Array("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat")
+  val MONTHS = Array("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
+  val MinValue = DateTime(1800, 1, 1)
+  val MaxValue = DateTime(2199, 12, 31, 23, 59, 59)
+
+  /**
+   * Creates a new `DateTime` with the given properties.
+   * Note that this implementation discards milliseconds (i.e. rounds down to full seconds).
+   */
+  def apply(year: Int, month: Int, day: Int, hour: Int = 0, minute: Int = 0, second: Int = 0): DateTime = {
+    require(1800 <= year && year <= 9999, "year must be >= 1800 and <= 9999")
+    require(1 <= month && month <= 12, "month must be >= 1 and <= 12")
+    require(1 <= day && day <= 31, "day must be >= 1 and <= 31")
+    require(0 <= hour && hour <= 23, "hour must be >= 0 and <= 23")
+    require(0 <= minute && minute <= 59, "minute_ must be >= 0 and <= 59")
+    require(0 <= second && second <= 59, "second must be >= 0 and <= 59")
+
+    // compute yearday from month/monthday
+    val m = month - 1
+    var d = (m % 7) * 30 + (m % 7 + 1) / 2 + day
+    val isLeap = ((year % 4 == 0) && !(year % 100 == 0)) || (year % 400 == 0)
+    if (m >= 7) d += 214
+    if (d >= 61) d -= 1 // skip non-existent Feb 30
+    if (!isLeap && (d >= 60)) d -= 1 // skip non-existent Feb 29
+
+    // convert year/yearday to days since Jan 1, 1970, 00:00:00
+    val y = year - 1
+    d += y * 365 + y / 4 - y / 100 + y / 400
+    val dn = d - (1969 * 365 + 492 - 19 + 4)
+    val c = (dn - 1) * 86400L + hour * 3600L + minute * 60L + second // seconds since Jan 1, 1970, 00:00:00
+
+    new DateTime(year, month, day, hour, minute, second, weekday = d % 7, clicks = c * 1000)
+  }
+
+  /**
+   * Creates a new `DateTime` from the number of milli seconds
+   * since the start of "the epoch", namely January 1, 1970, 00:00:00 GMT.
+   * Note that this implementation discards milliseconds (i.e. rounds down to full seconds).
+   */
+  def apply(clicks: Long): DateTime = {
+    require(DateTime.MinValue.clicks <= clicks && clicks <= DateTime.MaxValue.clicks,
+      "DateTime value must be >= " + DateTime.MinValue + " and <= " + DateTime.MaxValue)
+
+    // based on a fast RFC1123 implementation (C) 2000 by Tim Kientzle <kientzle@acm.org>
+    val c = clicks - clicks % 1000
+
+    // compute day number, seconds since beginning of day
+    var s = c
+    if (s >= 0) s /= 1000 // seconds since 1 Jan 1970
+    else s = (s - 999) / 1000 // floor(sec/1000)
+
+    var dn = (s / 86400).toInt
+    s %= 86400 // positive seconds since beginning of day
+    if (s < 0) { s += 86400; dn -= 1 }
+    dn += 1969 * 365 + 492 - 19 + 4 // days since "1 Jan, year 1"
+
+    // convert days since 1 Jan, year 1 to year/yearday
+    var y = 400 * (dn / 146097).toInt + 1
+    var d = dn % 146097
+    if (d == 146096) { y += 399; d = 365 } // last year of 400 is long
+    else {
+      y += 100 * (d / 36524)
+      d %= 36524
+      y += 4 * (d / 1461)
+      d %= 1461
+      if (d == 1460) { y += 3; d = 365 } // last year out of 4 is long
+      else {
+        y += d / 365
+        d %= 365
+      }
+    }
+
+    val isLeap = ((y % 4 == 0) && !(y % 100 == 0)) || (y % 400 == 0)
+
+    // compute month/monthday from year/yearday
+    if (!isLeap && (d >= 59)) d += 1 // skip non-existent Feb 29
+    if (d >= 60) d += 1 // skip non-existent Feb 30
+    var mon = ((d % 214) / 61) * 2 + ((d % 214) % 61) / 31
+    if (d > 213) mon += 7
+    d = ((d % 214) % 61) % 31 + 1
+
+    // convert second to hour/min/sec
+    var m = (s / 60).toInt
+    val h = m / 60
+    m %= 60
+    s %= 60
+    val w = (dn + 1) % 7 // day of week, 0==Sun
+
+    new DateTime(year = y, month = mon + 1, day = d, hour = h, minute = m, second = s.toInt, weekday = w, clicks = c)
+  }
+
+  /**
+   * Creates a new `DateTime` instance for the current point in time.
+   * Note that this implementation discards milliseconds (i.e. rounds down to full seconds).
+   */
+  def now: DateTime = apply(System.currentTimeMillis)
+
+  /**
+   * Creates a new DateTime instance from the given String,
+   * if it adheres to the format `yyyy-mm-ddThh:mm:ss[.SSSZ]`.
+   * Note that this implementation discards milliseconds (i.e. rounds down to full seconds).
+   */
+  def fromIsoDateTimeString(string: String): Option[DateTime] = {
+    def c(ix: Int) = string.charAt(ix)
+    def isDigit(c: Char) = '0' <= c && c <= '9'
+    def i(ix: Int) = {
+      val x = c(ix)
+      require(isDigit(x))
+      x - '0'
+    }
+    def check(len: Int): Boolean =
+      len match {
+        case 19 ⇒ c(4) == '-' && c(7) == '-' && c(10) == 'T' && c(13) == ':' && c(16) == ':'
+        case 24 ⇒ check(19) && c(19) == '.' && isDigit(c(20)) && isDigit(c(21)) && isDigit(c(22)) && c(23) == 'Z'
+        case _  ⇒ false
+      }
+    if (check(string.length)) {
+      try {
+        val year = i(0) * 1000 + i(1) * 100 + i(2) * 10 + i(3)
+        val month = i(5) * 10 + i(6)
+        val day = i(8) * 10 + i(9)
+        val hour = i(11) * 10 + i(12)
+        val min = i(14) * 10 + i(15)
+        val sec = i(17) * 10 + i(18)
+        Some(DateTime(year, month, day, hour, min, sec))
+      } catch { case _: IllegalArgumentException ⇒ None }
+    } else None
+  }
+
+  val UnixEpoch = DateTime(0L)
+
+  def unapply(dt: DateTime): Option[(Int, Int, Int, Int, Int, Int)] =
+    Some((dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second))
+}
\ No newline at end of file
diff --git a/core-js/src/main/scala/coursier/core/compatibility/package.scala b/core-js/src/main/scala/coursier/core/compatibility/package.scala
new file mode 100644
index 000000000..7766bc79b
--- /dev/null
+++ b/core-js/src/main/scala/coursier/core/compatibility/package.scala
@@ -0,0 +1,71 @@
+package coursier.core
+
+import scala.scalajs.js
+import org.scalajs.dom.raw.NodeList
+
+package object compatibility {
+  def option[A](a: js.Dynamic): Option[A] =
+    if (js.isUndefined(a)) None
+    else Some(a.asInstanceOf[A])
+  def dynOption(a: js.Dynamic): Option[js.Dynamic] =
+    if (js.isUndefined(a)) None
+    else Some(a)
+
+  private def between(c: Char, lower: Char, upper: Char) = lower <= c && c <= upper
+
+  implicit class RichChar(val c: Char) extends AnyVal {
+    def letterOrDigit: Boolean = {
+      between(c, '0', '9') || letter
+    }
+    def letter: Boolean = between(c, 'a', 'z') || between(c, 'A', 'Z')
+  }
+
+  lazy val DOMParser = {
+    import js.Dynamic.{global => g}
+    import js.DynamicImplicits._
+
+    val defn =
+      if (js.isUndefined(g.DOMParser)) g.require("xmldom").DOMParser
+      else g.DOMParser
+    js.Dynamic.newInstance(defn)()
+  }
+
+  def fromNode(node: org.scalajs.dom.raw.Node): Xml.Node = {
+
+    val node0 = node.asInstanceOf[js.Dynamic]
+
+    new Xml.Node {
+      def label =
+        option[String](node0.nodeName)
+          .getOrElse("")
+      def child =
+        option[NodeList](node0.childNodes)
+          .map(l => List.tabulate(l.length)(l.item).map(fromNode))
+          .getOrElse(Nil)
+
+      def isText =
+        option[Int](node0.nodeType)
+          .exists(_ == 3) //org.scalajs.dom.raw.Node.TEXT_NODE
+      def textContent =
+        option(node0.textContent)
+          .getOrElse("")
+      def isElement =
+        option[Int](node0.nodeType)
+          .exists(_ == 1) // org.scalajs.dom.raw.Node.ELEMENT_NODE
+    }
+  }
+
+
+  def xmlParse(s: String): Either[String, Xml.Node] = {
+    val doc = {
+      if (s.isEmpty) None
+      else
+        dynOption(DOMParser.parseFromString(s, "text/xml"))
+          .flatMap(t => dynOption(t.childNodes))
+          .flatMap(l => l.asInstanceOf[js.Array[js.Dynamic]].headOption.flatMap(option[org.scalajs.dom.raw.Node]))
+    }
+
+    Right(doc.fold(Xml.Node.empty)(fromNode))
+  }
+
+}
diff --git a/core-js/src/main/scala/coursier/repository/package.scala b/core-js/src/main/scala/coursier/repository/package.scala
new file mode 100644
index 000000000..59d758a39
--- /dev/null
+++ b/core-js/src/main/scala/coursier/repository/package.scala
@@ -0,0 +1,13 @@
+package coursier
+
+package object repository {
+
+  type Remote = core.Remote
+  val Remote: core.Remote.type = core.Remote
+
+  val mavenCentral = Remote("https://repo1.maven.org/maven2/")
+
+  val sonatypeReleases = Remote("https://oss.sonatype.org/content/repositories/releases/")
+  val sonatypeSnapshots = Remote("https://oss.sonatype.org/content/repositories/snapshots/")
+
+}
diff --git a/core-js/src/main/scala/scalaz/concurrent/package.scala b/core-js/src/main/scala/scalaz/concurrent/package.scala
new file mode 100644
index 000000000..c0ace3e11
--- /dev/null
+++ b/core-js/src/main/scala/scalaz/concurrent/package.scala
@@ -0,0 +1,42 @@
+package scalaz
+
+import scala.concurrent.{ExecutionContext, Future}
+
+/** Minimal Future-based Task */
+package object concurrent {
+
+  trait Task[T] { self =>
+    def map[U](f: T => U): Task[U] =
+      new Task[U] {
+        def runF(implicit ec: ExecutionContext) = self.runF.map(f)
+      }
+    def flatMap[U](f: T => Task[U]): Task[U] =
+      new Task[U] {
+        def runF(implicit ec: ExecutionContext) = self.runF.flatMap(f(_).runF)
+      }
+
+    def runF(implicit ec: ExecutionContext): Future[T]
+  }
+
+  object Task {
+    def now[A](a: A): Task[A] =
+      new Task[A] {
+        def runF(implicit ec: ExecutionContext) = Future.successful(a)
+      }
+    def apply[A](f: ExecutionContext => Future[A]): Task[A] =
+      new Task[A] {
+        def runF(implicit ec: ExecutionContext) = f(ec)
+      }
+    def gatherUnordered[T](tasks: Seq[Task[T]], exceptionCancels: Boolean = false): Task[Seq[T]] =
+      new Task[Seq[T]] {
+        def runF(implicit ec: ExecutionContext) = Future.traverse(tasks)(_.runF)
+      }
+
+    implicit val taskFunctor: Functor[Task] =
+      new Functor[Task] {
+        def map[A, B](fa: Task[A])(f: A => B): Task[B] =
+          fa.map(f)
+      }
+  }
+
+}
diff --git a/core-js/src/test/scala/coursier/test/JsTests.scala b/core-js/src/test/scala/coursier/test/JsTests.scala
new file mode 100644
index 000000000..30d8045d5
--- /dev/null
+++ b/core-js/src/test/scala/coursier/test/JsTests.scala
@@ -0,0 +1,41 @@
+package coursier
+package test
+
+import coursier.core.Remote
+import coursier.test.compatibility._
+
+import utest._
+
+import scala.concurrent.{Future, Promise}
+
+object JsTests extends TestSuite {
+
+  val tests = TestSuite {
+    'promise {
+      val p = Promise[Unit]()
+      Future(p.success(()))
+      p.future
+    }
+
+    'get{
+      Remote.get("http://repo1.maven.org/maven2/ch/qos/logback/logback-classic/1.1.3/logback-classic-1.1.3.pom")
+        .map{ xml =>
+          assert(xml.right.toOption.exists(_.label == "project"))
+        }
+    }
+
+    'getProj{
+      repository.mavenCentral
+        .find(Module("ch.qos.logback", "logback-classic", "1.1.3"))
+        .map{ proj =>
+          assert(proj.parent == Some(Module("ch.qos.logback", "logback-parent", "1.1.3")))
+        }
+        .run
+        .runF
+        .map{ res =>
+          assert(res.isRight)
+        }
+    }
+  }
+
+}
diff --git a/core-js/src/test/scala/coursier/test/compatibility/package.scala b/core-js/src/test/scala/coursier/test/compatibility/package.scala
new file mode 100644
index 000000000..377b8e7b2
--- /dev/null
+++ b/core-js/src/test/scala/coursier/test/compatibility/package.scala
@@ -0,0 +1,7 @@
+package coursier.test
+
+package object compatibility {
+
+  implicit val executionContext = scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
+
+}
diff --git a/core-jvm/src/main/scala/coursier/core/Remote.scala b/core-jvm/src/main/scala/coursier/core/Remote.scala
new file mode 100644
index 000000000..03110d01d
--- /dev/null
+++ b/core-jvm/src/main/scala/coursier/core/Remote.scala
@@ -0,0 +1,229 @@
+package coursier
+package core
+
+import java.io._
+import java.net.URL
+
+import org.http4s.{EntityDecoder, Status, Uri}
+
+import scala.annotation.tailrec
+import scala.io.Codec
+import scalaz._, Scalaz._
+import scalaz.concurrent.Task
+
+// FIXME This kind of side-effecting API is lame, we should aim at a more functional one.
+trait ArtifactDownloaderLogger {
+  def foundLocally(f: File): Unit
+  def downloadingArtifact(url: String): Unit
+  def downloadedArtifact(url: String, success: Boolean): Unit
+}
+
+case class ArtifactDownloader(root: Uri, cache: File, logger: Option[ArtifactDownloaderLogger] = None) {
+  var bufferSize = 1024*1024
+
+  def artifact(module: Module,
+               classifier: String,
+               `type`: String,
+               cachePolicy: CachePolicy): EitherT[Task, String, File] = {
+
+    val relPath =
+      module.organization.split('.').toSeq ++ Seq(
+        module.name,
+        module.version,
+        s"${module.name}-${module.version}${Some(classifier).filter(_.nonEmpty).map("-"+_).mkString}.${`type`}"
+      )
+
+    val file = (cache /: relPath)(new File(_, _))
+
+    def locally = {
+      Task {
+        if (file.exists()) {
+          logger.foreach(_.foundLocally(file))
+          \/-(file)
+        }
+        else -\/("Not found in cache")
+      }
+    }
+
+    def remote = {
+      // FIXME A lot of things can go wrong here and are not properly handled:
+      //  - checksums should be validated
+      //  - what if the connection gets closed during the transfer (partial file on disk)?
+      //  - what if someone is trying to write this file at the same time? (no locking of any kind yet)
+      //  - ...
+
+      val urlStr = (root resolve Uri(path = relPath.mkString("./", "/", ""))).renderString
+
+      Task {
+        try {
+          file.getParentFile.mkdirs()
+
+          logger.foreach(_.downloadingArtifact(urlStr))
+
+          val url = new URL(urlStr)
+          val b = Array.fill[Byte](bufferSize)(0)
+          val in = new BufferedInputStream(url.openStream(), bufferSize)
+
+          try {
+            val w = new FileOutputStream(file)
+            try {
+              @tailrec
+              def helper(): Unit = {
+                val read = in.read(b)
+                if (read >= 0) {
+                  w.write(b, 0, read)
+                  helper()
+                }
+              }
+
+              helper()
+            } finally w.close()
+          } finally in.close()
+
+          logger.foreach(_.downloadedArtifact(urlStr, success = true))
+          \/-(file)
+        }
+        catch { case e: Exception =>
+          logger.foreach(_.downloadedArtifact(urlStr, success = false))
+          -\/(e.getMessage)
+        }
+      }
+    }
+
+    EitherT(cachePolicy(locally)(remote))
+  }
+
+  def artifact(dependency: Dependency,
+               cachePolicy: CachePolicy = CachePolicy.Default): EitherT[Task, String, File] =
+    artifact(dependency.module, dependency.classifier, dependency.`type`, cachePolicy = cachePolicy)
+
+}
+
+// FIXME Comment of ArtifactDownloaderLogger applies here too
+trait RemoteLogger {
+  def downloading(url: String): Unit
+  def downloaded(url: String, success: Boolean): Unit
+  def readingFromCache(f: File): Unit
+  def puttingInCache(f: File): Unit
+}
+
+case class Remote(root: Uri, cache: Option[File] = None, logger: Option[RemoteLogger] = None) extends Repository {
+  lazy val client = org.http4s.client.blaze.defaultClient
+
+  def find(module: Module,
+           cachePolicy: CachePolicy): EitherT[Task, String, Project] = {
+
+    val relPath =
+      module.organization.split('.').toSeq ++ Seq(
+        module.name,
+        module.version,
+        s"${module.name}-${module.version}.pom"
+      )
+
+    def localFile = {
+      for {
+        cache0 <- cache.toRightDisjunction("No cache")
+        f = (cache0 /: relPath)(new File(_, _))
+      } yield f
+    }
+
+    def locally = {
+      Task {
+        for {
+          f0 <- localFile
+          f <- Some(f0).filter(_.exists()).toRightDisjunction("Not found in cache")
+          content <- \/.fromTryCatchNonFatal{
+            logger.foreach(_.readingFromCache(f))
+            scala.io.Source.fromFile(f)(Codec.UTF8).mkString
+          }.leftMap(_.getMessage)
+        } yield content
+      }
+    }
+
+    def remote = {
+      val uri = root resolve Uri(path = relPath.mkString("./", "/", ""))
+      val log = Task(logger.foreach(_.downloading(uri.renderString)))
+      val get = log.flatMap(_ => client(uri))
+
+      get.flatMap{ resp =>
+        val success = resp.status == Status.Ok
+        logger.foreach(_.downloaded(uri.renderString, success))
+
+        if (success)
+          EntityDecoder.text.decode(resp).run.map(_.leftMap(_.sanitized))
+        else
+          Task.now(-\/(s"Unhandled or bad status ${resp.status.code} from repository (${resp.status.code} ${resp.status.reason})"))
+      }
+    }
+
+    def save(s: String) = {
+      localFile.fold(_ => Task.now(()), f =>
+        Task {
+          if (!f.exists()) {
+            logger.foreach(_.puttingInCache(f))
+            f.getParentFile.mkdirs()
+            val w = new PrintWriter(f)
+            try w.write(s)
+            finally w.close()
+            ()
+          }
+        }
+      )
+    }
+
+    val task = cachePolicy.saving(locally)(remote)(save)
+      .map(eitherStr =>
+        for {
+          str <- eitherStr
+          xml <- \/.fromEither(compatibility.xmlParse(str))
+          _ <- if (xml.label == "project") \/-(()) else -\/("Project definition not found")
+          proj <- Xml.project(xml)
+        } yield proj
+      )
+
+    EitherT(task)
+  }
+
+  def versions(organization: String,
+               name: String,
+               cachePolicy: CachePolicy): EitherT[Task, String, Versions] = {
+
+    val relPath =
+      organization.split('.').toSeq ++ Seq(
+        name,
+        "maven-metadata.xml"
+      )
+
+    def locally = {
+      ???
+    }
+
+    def remote = {
+      val respTask = client(root resolve Uri(path = relPath.mkString("./", "/", "")))
+
+      respTask.flatMap{ resp =>
+        if (resp.status == Status.Ok)
+          EntityDecoder.text.decode(resp).run.map(_.leftMap(_.sanitized))
+        else
+          Task.now(-\/(s"Unhandled or bad status ${resp.status.code} from repository (${resp.status.code} ${resp.status.reason})"))
+      }
+    }
+
+    def save(s: String) = {
+      // TODO
+      Task.now(())
+    }
+
+    val task = cachePolicy.saving(locally)(remote)(save)
+      .map(eitherStr =>
+        for {
+          str <- eitherStr
+          xml <- \/.fromEither(compatibility.xmlParse(str))
+          _ <- if (xml.label == "metadata") \/-(()) else -\/("Metadata not found")
+          versions <- Xml.versions(xml)
+        } yield versions
+      )
+
+    EitherT(task)
+  }
+}
diff --git a/core-jvm/src/main/scala/coursier/core/compatibility/package.scala b/core-jvm/src/main/scala/coursier/core/compatibility/package.scala
new file mode 100644
index 000000000..53760b155
--- /dev/null
+++ b/core-jvm/src/main/scala/coursier/core/compatibility/package.scala
@@ -0,0 +1,34 @@
+package coursier.core
+
+package object compatibility {
+
+  type DateTime = org.http4s.DateTime
+  val DateTime: org.http4s.DateTime.type = org.http4s.DateTime
+
+  implicit class RichChar(val c: Char) extends AnyVal {
+    def letterOrDigit = c.isLetterOrDigit
+    def letter = c.isLetter
+  }
+
+  def xmlParse(s: String): Either[String, Xml.Node] = {
+    def parse =
+      try Right(scala.xml.XML.loadString(s))
+      catch { case e: Exception => Left(e.getMessage) }
+
+    def fromNode(node: scala.xml.Node): Xml.Node =
+      new Xml.Node {
+        def label = node.label
+        def child = node.child.map(fromNode)
+        def isText = node match { case _: scala.xml.Text => true; case _ => false }
+        def textContent = node match {
+          case t: scala.xml.Text => t.data
+          case _ => throw new NoSuchElementException("text of non text node")
+        }
+        def isElement = node match { case _: scala.xml.Elem => true; case _ => false }
+      }
+
+    parse.right
+      .map(fromNode)
+  }
+
+}
diff --git a/core-jvm/src/main/scala/coursier/core/package.scala b/core-jvm/src/main/scala/coursier/core/package.scala
new file mode 100644
index 000000000..b4663e5dc
--- /dev/null
+++ b/core-jvm/src/main/scala/coursier/core/package.scala
@@ -0,0 +1,31 @@
+package coursier
+
+import scalaz.EitherT
+import scalaz.concurrent.Task
+
+package object core {
+
+  def resolution(dependencies: Set[Dependency],
+                 fetch: Module => EitherT[Task, List[String], (Repository, Project)],
+                 filter: Option[Dependency => Boolean],
+                 profileActivation: Option[(String, Activation, Map[String, String]) => Boolean]): Stream[Resolution] = {
+
+    val startResolution = Resolution(
+      dependencies, dependencies, Set.empty,
+      Map.empty, Map.empty,
+      filter,
+      profileActivation
+    )
+
+    def helper(resolution: Resolution): Stream[Resolution] = {
+      if (resolution.isDone) Stream()
+      else {
+        val nextRes = resolution.next(fetch).run
+        nextRes #:: helper(nextRes)
+      }
+    }
+
+    startResolution #:: helper(startResolution)
+  }
+
+}
diff --git a/core-jvm/src/main/scala/coursier/repository/package.scala b/core-jvm/src/main/scala/coursier/repository/package.scala
new file mode 100644
index 000000000..8c2da5da3
--- /dev/null
+++ b/core-jvm/src/main/scala/coursier/repository/package.scala
@@ -0,0 +1,15 @@
+package coursier
+
+import org.http4s.Http4s._
+
+package object repository {
+
+  type Remote = core.Remote
+  val Remote: core.Remote.type = core.Remote
+
+  val mavenCentral = Remote(uri("https://repo1.maven.org/maven2/"))
+
+  val sonatypeReleases = Remote(uri("https://oss.sonatype.org/content/repositories/releases/"))
+  val sonatypeSnapshots = Remote(uri("https://oss.sonatype.org/content/repositories/snapshots/"))
+
+}
diff --git a/core-jvm/src/test/scala/coursier/test/compatibility/package.scala b/core-jvm/src/test/scala/coursier/test/compatibility/package.scala
new file mode 100644
index 000000000..6196b421c
--- /dev/null
+++ b/core-jvm/src/test/scala/coursier/test/compatibility/package.scala
@@ -0,0 +1,14 @@
+package coursier.test
+
+import scala.concurrent.Future
+import scalaz.concurrent.Task
+
+package object compatibility {
+
+  implicit val executionContext = scala.concurrent.ExecutionContext.global
+
+  implicit class TaskExtensions[T](val underlying: Task[T]) extends AnyVal {
+    def runF: Future[T] = Future.successful(underlying.run)
+  }
+
+}
diff --git a/core/src/main/scala/coursier/core/ComparableVersion.scala b/core/src/main/scala/coursier/core/ComparableVersion.scala
new file mode 100644
index 000000000..fcea0a119
--- /dev/null
+++ b/core/src/main/scala/coursier/core/ComparableVersion.scala
@@ -0,0 +1,205 @@
+package coursier.core
+
+import scala.annotation.tailrec
+import coursier.core.compatibility._
+
+/** Same kind of ordering as aether-util/src/main/java/org/eclipse/aether/util/version/GenericVersion.java */
+object ComparableVersion {
+
+  sealed trait Item extends Ordered[Item] {
+    def compare(other: Item): Int =
+      (this, other) match {
+        case (Number(a), Number(b)) => a.compare(b)
+        case (BigNumber(a), BigNumber(b)) => a.compare(b)
+        case (Number(a), BigNumber(b)) => -b.compare(a)
+        case (BigNumber(a), Number(b)) => a.compare(b)
+        case (Qualifier(_, a), Qualifier(_, b)) => a.compare(b)
+        case (Literal(a), Literal(b)) => a.compareToIgnoreCase(b)
+
+        case _ =>
+          val rel0 = compareToEmpty
+          val rel1 = other.compareToEmpty
+
+          if (rel0 == rel1) order.compare(other.order)
+          else rel0.compare(rel1)
+      }
+
+    def order: Int
+    def isEmpty: Boolean = compareToEmpty == 0
+    def compareToEmpty: Int = 1
+  }
+
+  sealed trait Numeric extends Item
+  case class Number(value: Int) extends Numeric {
+    val order = 0
+    override def compareToEmpty = value.compare(0)
+  }
+  case class BigNumber(value: BigInt) extends Numeric {
+    val order = 0
+    override def compareToEmpty = value.compare(0)
+  }
+  case class Qualifier(value: String, level: Int) extends Item {
+    val order = -2
+    override def compareToEmpty = level.compare(0)
+  }
+  case class Literal(value: String) extends Item {
+    val order = -1
+    override def compareToEmpty = if (value.isEmpty) 0 else 1
+  }
+
+  case object Min extends Item {
+    val order = -8
+    override def compareToEmpty = -1
+  }
+  case object Max extends Item {
+    val order = 8
+  }
+
+  val empty = Number(0)
+
+  val qualifiers = Seq[Qualifier](
+    Qualifier("alpha", -5),
+    Qualifier("beta", -4),
+    Qualifier("milestone", -3),
+    Qualifier("cr", -2),
+    Qualifier("rc", -2),
+    Qualifier("snapshot", -1),
+    Qualifier("ga", 0),
+    Qualifier("final", 0),
+    Qualifier("sp", 1)
+  )
+
+  val qualifiersMap = qualifiers.map(q => q.value -> q).toMap
+
+  object Tokenizer {
+    sealed trait Separator
+    case object Dot extends Separator
+    case object Hyphen extends Separator
+    case object Underscore extends Separator
+    case object None extends Separator
+
+    def apply(s: String): (Item, Stream[(Separator, Item)]) = {
+      def parseItem(s: Stream[Char]): (Item, Stream[Char]) = {
+        if (s.isEmpty || !s.head.letterOrDigit) (empty, s)
+        else if (s.head.isDigit) {
+          def digits(b: StringBuilder, s: Stream[Char]): (String, Stream[Char]) =
+            if (s.isEmpty || !s.head.isDigit) (b.result(), s)
+            else digits(b + s.head, s.tail)
+
+          val (digits0, rem) = digits(new StringBuilder, s)
+          val item =
+            if (digits0.length >= 10) BigNumber(BigInt(digits0))
+            else Number(digits0.toInt)
+
+          (item, rem)
+        } else {
+          assert(s.head.letter)
+
+          def letters(b: StringBuilder, s: Stream[Char]): (String, Stream[Char]) =
+            if (s.isEmpty || !s.head.letter) (b.result().toLowerCase, s)
+            else letters(b + s.head, s.tail)
+
+          val (letters0, rem) = letters(new StringBuilder, s)
+          val item =
+            qualifiersMap.getOrElse(letters0, Literal(letters0))
+
+          (item, rem)
+        }
+      }
+
+      def parseSeparator(s: Stream[Char]): (Separator, Stream[Char]) = {
+        assert(s.nonEmpty)
+
+        s.head match {
+          case '.' => (Dot, s.tail)
+          case '-' => (Hyphen, s.tail)
+          case '_' => (Underscore, s.tail)
+          case _ => (None, s)
+        }
+      }
+
+      def helper(s: Stream[Char]): Stream[(Separator, Item)] = {
+        if (s.isEmpty) Stream()
+        else {
+          val (sep, rem0) = parseSeparator(s)
+          val (item, rem) = parseItem(rem0)
+
+          (sep, item) #:: helper(rem)
+        }
+      }
+
+      val (first, rem) = parseItem(s.toStream)
+      (first, helper(rem))
+    }
+  }
+
+  def parse(s: String): ComparableVersion = {
+    val (first, tokens) = Tokenizer(s)
+
+    def isNumeric(item: Item) = item match { case _: Numeric => true; case _ => false }
+
+    def postProcess(prevIsNumeric: Option[Boolean], item: Item, tokens0: Stream[(Tokenizer.Separator, Item)]): Stream[Item] = {
+      val tokens = {
+        var _tokens = tokens0
+
+        if (isNumeric(item)) {
+          val nextNonDotZero = _tokens.dropWhile{case (Tokenizer.Dot, n: Numeric) => n.isEmpty; case _ => false }
+          if (nextNonDotZero.forall(t => t._1 == Tokenizer.Hyphen || ((t._1 == Tokenizer.Dot || t._1 == Tokenizer.None) && !isNumeric(t._2)))) { // Dot && isNumeric(t._2)
+            _tokens = nextNonDotZero
+          }
+        }
+
+        _tokens
+      }
+
+      def ifFollowedByNumberElse(ifFollowedByNumber: Item, default: Item) = {
+        val followedByNumber = tokens.headOption
+          .exists{ case (Tokenizer.None, num: Numeric) if !num.isEmpty => true; case _ => false }
+
+        if (followedByNumber) ifFollowedByNumber
+        else default
+      }
+
+      def next =
+        if (tokens.isEmpty) Stream()
+        else postProcess(Some(isNumeric(item)), tokens.head._2, tokens.tail)
+
+      item match {
+        case Literal("min") => Min #:: next
+        case Literal("max") => Max #:: next
+        case Literal("a") =>
+          ifFollowedByNumberElse(qualifiersMap("alpha"), item) #:: next
+        case Literal("b") =>
+          ifFollowedByNumberElse(qualifiersMap("beta"), item) #:: next
+        case Literal("m") =>
+          ifFollowedByNumberElse(qualifiersMap("milestone"), item) #:: next
+        case _ =>
+          item #:: next
+      }
+    }
+
+    ComparableVersion(postProcess(None, first, tokens).toList)
+  }
+
+  @tailrec
+  def listCompare(first: List[Item], second: List[Item]): Int = {
+    if (first.isEmpty && second.isEmpty) 0
+    else if (first.isEmpty) {
+      assert(second.nonEmpty)
+      -second.dropWhile(_.isEmpty).headOption.fold(0)(_.compareToEmpty)
+    } else if (second.isEmpty) {
+      assert(first.nonEmpty)
+      first.dropWhile(_.isEmpty).headOption.fold(0)(_.compareToEmpty)
+    } else {
+      val rel = first.head.compare(second.head)
+      if (rel == 0) listCompare(first.tail, second.tail)
+      else rel
+    }
+  }
+
+}
+
+case class ComparableVersion(items: List[ComparableVersion.Item]) extends Ordered[ComparableVersion] {
+  def compare(other: ComparableVersion) = ComparableVersion.listCompare(items, other.items)
+  def isEmpty = items.forall(_.isEmpty)
+}
diff --git a/core/src/main/scala/coursier/core/Definitions.scala b/core/src/main/scala/coursier/core/Definitions.scala
new file mode 100644
index 000000000..2b1e1b7dd
--- /dev/null
+++ b/core/src/main/scala/coursier/core/Definitions.scala
@@ -0,0 +1,47 @@
+package coursier.core
+
+case class Module(organization: String,
+                  name: String,
+                  version: String) {
+
+  def trim: Module = copy(
+    organization = organization.trim,
+    name = name.trim,
+    version = version.trim
+  )
+  override def toString = s"$organization:$name:$version"
+}
+
+sealed abstract class Scope(val name: String)
+
+case class Dependency(module: Module,
+                      scope: Scope,
+                      `type`: String,
+                      classifier: String,
+                      exclusions: Set[(String, String)],
+                      optional: Boolean)
+
+case class Project(module: Module,
+                   dependencies: Seq[Dependency],
+                   parent: Option[Module],
+                   dependencyManagement: Seq[Dependency],
+                   properties: Map[String, String],
+                   profiles: Seq[Profile])
+
+object Scope {
+  case object Compile extends Scope("compile")
+  case object Runtime extends Scope("runtime")
+  case object Test extends Scope("test")
+  case object Provided extends Scope("provided")
+  case object Import extends Scope("import")
+  case class Other(override val name: String) extends Scope(name)
+}
+
+case class Activation(properties: Seq[(String, Option[String])])
+
+case class Profile(id: String,
+                   activeByDefault: Option[Boolean],
+                   activation: Activation,
+                   dependencies: Seq[Dependency],
+                   dependencyManagement: Seq[Dependency],
+                   properties: Map[String, String])
diff --git a/core/src/main/scala/coursier/core/Parse.scala b/core/src/main/scala/coursier/core/Parse.scala
new file mode 100644
index 000000000..083d9010e
--- /dev/null
+++ b/core/src/main/scala/coursier/core/Parse.scala
@@ -0,0 +1,43 @@
+package coursier.core
+
+import coursier.core.compatibility._
+
+object Parse {
+
+  def scope(s: String): Scope = s match {
+    case "compile" => Scope.Compile
+    case "runtime" => Scope.Runtime
+    case "test" => Scope.Test
+    case "provided" => Scope.Provided
+    case "import" => Scope.Import
+    case other => Scope.Other(other)
+  }
+
+  def version(s: String): Option[Version] = {
+    if (s.isEmpty || s.exists(c => c != '.' && c != '-' && c != '_' && !c.letterOrDigit)) None
+    else Some(Version(s))
+  }
+
+  def versionInterval(s: String): Option[VersionInterval] = {
+    for {
+      fromIncluded <- if (s.startsWith("[")) Some(true) else if (s.startsWith("(")) Some(false) else None
+      toIncluded <- if (s.endsWith("]")) Some(true) else if (s.endsWith(")")) Some(false) else None
+      s0 = s.drop(1).dropRight(1)
+      commaIdx = s0.indexOf(',')
+      if commaIdx >= 0
+      strFrom = s0.take(commaIdx)
+      strTo = s0.drop(commaIdx + 1)
+      from <- if (strFrom.isEmpty) Some(None) else version(strFrom).map(Some(_))
+      to <- if (strTo.isEmpty) Some(None) else version(strTo).map(Some(_))
+    } yield VersionInterval(from.filterNot(_.cmp.isEmpty), to.filterNot(_.cmp.isEmpty), fromIncluded, toIncluded)
+  }
+
+  def versionConstraint(s: String): Option[VersionConstraint] = {
+    def noConstraint = if (s.isEmpty) Some(VersionConstraint.None) else None
+
+    noConstraint
+      .orElse(version(s).map(VersionConstraint.Preferred))
+      .orElse(versionInterval(s).map(VersionConstraint.Interval))
+  }
+
+}
diff --git a/core/src/main/scala/coursier/core/Repository.scala b/core/src/main/scala/coursier/core/Repository.scala
new file mode 100644
index 000000000..595c285db
--- /dev/null
+++ b/core/src/main/scala/coursier/core/Repository.scala
@@ -0,0 +1,38 @@
+package coursier.core
+
+import scalaz.{\/, EitherT}
+import scalaz.concurrent.Task
+
+trait Repository {
+  def find(module: Module, cachePolicy: CachePolicy = CachePolicy.Default): EitherT[Task, String, Project]
+  def versions(organization: String, name: String, cachePolicy: CachePolicy = CachePolicy.Default): EitherT[Task, String, Versions]
+}
+
+sealed trait CachePolicy {
+  def apply[E,T](local: => Task[E \/ T])(remote: => Task[E \/ T]): Task[E \/ T]
+
+  def saving[E,T](local: => Task[E \/ T])(remote: => Task[E \/ T])(save: => T => Task[Unit]): Task[E \/ T] =
+    apply(local)(CachePolicy.saving(remote)(save))
+}
+
+object CachePolicy {
+  def saving[E,T](remote: => Task[E \/ T])(save: T => Task[Unit]): Task[E \/ T] = {
+    for {
+      res <- remote
+      _ <- res.fold(_ => Task.now(()), t => save(t))
+    } yield res
+  }
+
+  case object Default extends CachePolicy {
+    def apply[E,T](local: => Task[E \/ T])(remote: => Task[E \/ T]): Task[E \/ T] =
+      local.flatMap(res => if (res.isLeft) remote else Task.now(res))
+  }
+  case object LocalOnly extends CachePolicy {
+    def apply[E,T](local: => Task[E \/ T])(remote: => Task[E \/ T]): Task[E \/ T] =
+      local
+  }
+  case object ForceDownload extends CachePolicy {
+    def apply[E,T](local: => Task[E \/ T])(remote: => Task[E \/ T]): Task[E \/ T] =
+      remote
+  }
+}
diff --git a/core/src/main/scala/coursier/core/Resolver.scala b/core/src/main/scala/coursier/core/Resolver.scala
new file mode 100644
index 000000000..c0b486daf
--- /dev/null
+++ b/core/src/main/scala/coursier/core/Resolver.scala
@@ -0,0 +1,717 @@
+package coursier.core
+
+import java.util.regex.Pattern.quote
+
+import scala.annotation.tailrec
+import scalaz.concurrent.Task
+import scalaz.{EitherT, \/-, \/, -\/}
+
+object Resolver {
+
+  /**
+   * Try to find `module` among `repositories`.
+   */
+  def find(repositories: Seq[Repository],
+           module: Module): EitherT[Task, List[String], (Repository, Project)] = {
+
+    val lookups = repositories.map(repo => repo -> repo.find(module).run)
+    val task = lookups.foldLeft(Task.now(-\/(Nil)): Task[List[String] \/ (Repository, Project)]) {
+      case (acc, (repo, t)) =>
+        acc.flatMap {
+          case -\/(errors) =>
+            t.map(res => res
+              .flatMap(project =>
+                if (project.module == module) \/-((repo, project))
+                else -\/(s"Wrong module returned (expected: $module, got: ${project.module})")
+              )
+              .leftMap(error => error :: errors)
+            )
+
+          case res @ \/-(_) =>
+            Task.now(res)
+        }
+    }
+
+    EitherT(task.map(_.leftMap(_.reverse))).map { case x @ (_, proj) =>
+      assert(proj.module == module)
+      x
+    }
+  }
+
+  /**
+   * Get the active profiles of `project`, using the current properties `properties`,
+   * and `profileActivation` stating if a profile is active.
+   */
+  def profiles(project: Project,
+               properties: Map[String, String],
+               profileActivation: (String, Activation, Map[String, String]) => Boolean): Seq[Profile] = {
+
+    val activated = project.profiles
+      .filter(p => profileActivation(p.id, p.activation, properties))
+
+    def default = project.profiles
+      .filter(_.activeByDefault.toSeq.contains(true))
+
+    if (activated.isEmpty) default
+    else activated
+  }
+
+  type DepMgmtKey = (String, String, String)
+  def dependencyManagementKey(dep: Dependency): DepMgmtKey =
+    (dep.module.organization, dep.module.name, dep.`type`)
+  def dependencyManagementAdd(m: Map[DepMgmtKey, Dependency], dep: Dependency): Map[DepMgmtKey, Dependency] = {
+    val key = dependencyManagementKey(dep)
+    if (m.contains(key)) m else m + (key -> dep)
+  }
+  def dependencyManagementAddSeq(m: Map[DepMgmtKey, Dependency], deps: Seq[Dependency]): Map[DepMgmtKey, Dependency] =
+    (m /: deps)(dependencyManagementAdd)
+
+  def mergeProperties(m: Map[String, String], other: Map[String, String]): Map[String, String] = {
+    m ++ other.filterKeys(!m.contains(_))
+  }
+
+  def addDependencies(deps: Seq[Seq[Dependency]]): Seq[Dependency] = {
+    val res =
+      deps.foldRight((Set.empty[DepMgmtKey], Seq.empty[Dependency])) {
+        case (deps0, (set, acc)) =>
+          val deps = deps0.filter(dep => !set(dependencyManagementKey(dep)))
+          (set ++ deps.map(dependencyManagementKey), acc ++ deps)
+      }
+
+    res._2
+  }
+
+  val propRegex = (quote("${") + "([a-zA-Z0-9-.]*)" + quote("}")).r
+
+  /**
+   * Substitutes `properties` in `dependencies`.
+   */
+  def withProperties(dependencies: Seq[Dependency],
+                     properties: Map[String, String]): Seq[Dependency] = {
+
+    def substituteProps(s: String) = {
+      val matches = propRegex.findAllMatchIn(s).toList.reverse
+      if (matches.isEmpty) s
+      else {
+        val output = (new StringBuilder(s) /: matches) {
+          (b, m) => properties.get(m.group(1)).fold(b)(b.replace(m.start, m.end, _))
+        }
+        output.result()
+      }
+    }
+
+    dependencies.map{ dep =>
+      dep.copy(
+        module = dep.module.copy(
+          organization = substituteProps(dep.module.organization),
+          name = substituteProps(dep.module.name),
+          version = substituteProps(dep.module.version)
+        ),
+        `type` = substituteProps(dep.`type`),
+        scope = Parse.scope(substituteProps(dep.scope.name)),
+        exclusions = dep.exclusions
+          .map{case (org, name) => (substituteProps(org), substituteProps(name))}
+        // FIXME The content of the optional tag may also be a property in the original POM.
+        // Maybe not parse it that earlier?
+      )
+    }
+  }
+
+  /**
+   * Merge several version constraints together. Returns `None` in case of conflict.
+   */
+  def mergeVersions(versions: Seq[String]): Option[String] = {
+    val (nonParsedConstraints, parsedConstraints) =
+      versions
+        .map(v => v -> Parse.versionConstraint(v))
+        .partition(_._2.isEmpty)
+
+    if (nonParsedConstraints.nonEmpty)
+      Console.err.println(s"Ignoring unparsed versions: ${nonParsedConstraints.map(_._1)}")
+
+    val constraintOpt =
+      (Option(VersionInterval.zero) /: parsedConstraints.map(_._2.get.interval)) {
+        case (acc, itv) => acc.flatMap(_.merge(itv))
+      } .map(_.constraint)
+
+    constraintOpt.map(_.repr)
+  }
+
+  /**
+   * Merge several dependencies, solving version constraints of duplicated modules.
+   * Returns the conflicted dependencies, and the (solved) others.
+   */
+  def merge(dependencies: TraversableOnce[Dependency]): (Seq[Dependency], Seq[Dependency]) = {
+    val m = dependencies
+      .toList
+      .groupBy(dep => (dep.module.organization, dep.module.name))
+      .mapValues{ deps =>
+        if (deps.lengthCompare(1) == 0) List(\/-(deps.head))
+        else {
+          val scopeTypeClassifiers = (Set.empty[(Scope, String, String)] /: deps)((acc, dep) => acc + ((dep.scope, dep.`type`, dep.classifier)))
+
+          val versions = deps.map(_.module.version).distinct
+          val versionOpt = mergeVersions(versions)
+
+          scopeTypeClassifiers.toList.flatMap{case (scope, type0, classifier) =>
+            val scopeTypeClassifierDeps =
+              deps.filter(dep =>
+                dep.scope == scope && dep.`type` == type0 && dep.classifier == classifier
+              )
+
+            def dep(version: String) = {
+              Dependency(
+                deps.head.module.copy(version = version),
+                scope,
+                type0,
+                classifier,
+                scopeTypeClassifierDeps.map(_.exclusions.toSet).reduce(exclusionsIntersect),
+                scopeTypeClassifierDeps.forall(_.optional)
+              )
+            }
+
+            versionOpt match {
+              case Some(version) => List(\/-(dep(version)))
+              case None => versions.map(version => -\/(dep(version)))
+            }
+          }
+        }
+      }
+
+    val l = m.values.toList.flatten
+    (l.collect{case -\/(dep) => dep}, l.collect{case \/-(dep) => dep})
+  }
+
+  /**
+   * If one of our dependency has scope `base`, and a transitive dependency of it has scope `transitive`,
+   * return the scope of the latter for us, if any. If empty, means the transitive dependency
+   * should not be considered a dependency for us.
+   *
+   * See https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html#Dependency_Scope.
+   */
+  def resolveScope(base: Scope,
+                   transitive: Scope): Option[Scope] =
+    (base, transitive) match {
+      case (Scope.Compile, other) => Some(other)
+      case (Scope.Runtime, Scope.Compile) => Some(Scope.Runtime)
+      case (Scope.Runtime, other) => Some(other)
+      case _ => None
+    }
+
+  /**
+   * Applies `dependencyManagement` to `dependencies`.
+   *
+   * Fill empty version / scope / exclusions, for dependencies found in `dependencyManagement`.
+   */
+  def depsWithDependencyManagement(dependencies: Seq[Dependency],
+                                   dependencyManagement: Seq[Dependency]): Seq[Dependency] = {
+
+    // See http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html#Dependency_Management
+
+    lazy val m = dependencyManagementAddSeq(Map.empty, dependencyManagement)
+
+    dependencies.map { dep0 =>
+      var dep = dep0
+
+      for (mgmtDep <- m.get(dependencyManagementKey(dep0))) {
+        if (dep.module.version.isEmpty)
+          dep = dep.copy(module = dep.module.copy(version = mgmtDep.module.version))
+        if (dep.scope.name.isEmpty)
+          dep = dep.copy(scope = mgmtDep.scope)
+
+        if (dep.exclusions.isEmpty)
+          dep = dep.copy(exclusions = mgmtDep.exclusions)
+      }
+      
+      dep
+    }
+  }
+
+  /**
+   * Addition of exclusions. A module is excluded by the result if it is excluded
+   * by `first`, by `second`, or by both.
+   */
+  def exclusionsAdd(first: Set[(String, String)],
+                    second: Set[(String, String)]): Set[(String, String)] = {
+
+    val (firstAll, firstNonAll) = first.partition{case ("*", "*") => true; case _ => false }
+    val (secondAll, secondNonAll) = second.partition{case ("*", "*") => true; case _ => false }
+
+    if (firstAll.nonEmpty || secondAll.nonEmpty) Set(("*", "*"))
+    else {
+      val firstOrgWildcards = firstNonAll.collect{ case ("*", name) => name }
+      val firstNameWildcards = firstNonAll.collect{ case (org, "*") => org }
+      val secondOrgWildcards = secondNonAll.collect{ case ("*", name) => name }
+      val secondNameWildcards = secondNonAll.collect{ case (org, "*") => org }
+
+      val orgWildcards = firstOrgWildcards ++ secondOrgWildcards
+      val nameWildcards = firstNameWildcards ++ secondNameWildcards
+
+      val firstRemaining = firstNonAll.filter{ case (org, name) => org != "*" && name != "*" }
+      val secondRemaining = secondNonAll.filter{ case (org, name) => org != "*" && name != "*" }
+
+      val remaining = (firstRemaining ++ secondRemaining).filterNot{case (org, name) => orgWildcards(name) || nameWildcards(org) }
+
+      orgWildcards.map(name => ("*", name)) ++ nameWildcards.map(org => (org, "*")) ++ remaining
+    }
+  }
+
+  /**
+   * Intersection of exclusions. A module is excluded by the result if it is excluded
+   * by both `first` and `second`.
+   */
+  def exclusionsIntersect(first: Set[(String, String)],
+                          second: Set[(String, String)]): Set[(String, String)] = {
+
+    val (firstAll, firstNonAll) = first.partition{case ("*", "*") => true; case _ => false }
+    val (secondAll, secondNonAll) = second.partition{case ("*", "*") => true; case _ => false }
+
+    if (firstAll.nonEmpty && secondAll.nonEmpty) Set(("*", "*"))
+    else {
+      val firstOrgWildcards = firstNonAll.collect{ case ("*", name) => name }
+      val firstNameWildcards = firstNonAll.collect{ case (org, "*") => org }
+      val secondOrgWildcards = secondNonAll.collect{ case ("*", name) => name }
+      val secondNameWildcards = secondNonAll.collect{ case (org, "*") => org }
+
+      val orgWildcards =
+        (firstOrgWildcards intersect secondOrgWildcards) ++
+          (if (secondAll.nonEmpty) firstOrgWildcards else Set.empty) ++
+          (if (firstAll.nonEmpty) secondOrgWildcards else Set.empty)
+
+      val nameWildcards =
+        (firstNameWildcards intersect secondNameWildcards) ++
+          (if (secondAll.nonEmpty) firstNameWildcards else Set.empty) ++
+          (if (firstAll.nonEmpty) secondNameWildcards else Set.empty)
+
+      val firstRemaining = firstNonAll.filter{ case (org, name) => org != "*" && name != "*" }
+      val secondRemaining = secondNonAll.filter{ case (org, name) => org != "*" && name != "*" }
+
+      val remaining =
+        (firstRemaining intersect secondRemaining) ++
+          (if (secondAll.nonEmpty) firstRemaining else Set.empty) ++
+          (if (firstAll.nonEmpty) secondRemaining else Set.empty) ++
+          (if (secondOrgWildcards.nonEmpty) firstRemaining.filter(e => secondOrgWildcards(e._2)) else Set.empty) ++
+          (if (firstOrgWildcards.nonEmpty) secondRemaining.filter(e => firstOrgWildcards(e._2)) else Set.empty) ++
+          (if (secondNameWildcards.nonEmpty) firstRemaining.filter(e => secondNameWildcards(e._1)) else Set.empty) ++
+          (if (firstNameWildcards.nonEmpty) secondRemaining.filter(e => firstNameWildcards(e._1)) else Set.empty)
+
+      orgWildcards.map(name => ("*", name)) ++ nameWildcards.map(org => (org, "*")) ++ remaining
+    }
+  }
+
+  def withDefaultScope(dep: Dependency): Dependency =
+    if (dep.scope.name.isEmpty) dep.copy(scope = Scope.Compile)
+    else dep
+
+  /**
+   * Filters `deps` with `exclusions`.
+   */
+  def withExclusions(dependencies: Seq[Dependency],
+                     exclusions: Set[(String, String)]): Seq[Dependency] = {
+
+    val (all, notAll) = exclusions.partition{case ("*", "*") => true; case _ => false}
+
+    val orgWildcards = notAll.collect{case ("*", name) => name }
+    val nameWildcards = notAll.collect{case (org, "*") => org }
+
+    val remaining = notAll.filterNot{case (org, name) => org == "*" || name == "*" }
+
+    dependencies
+      .filter(dep =>
+        all.isEmpty &&
+          !orgWildcards(dep.module.name) &&
+          !nameWildcards(dep.module.organization) &&
+          !remaining((dep.module.organization, dep.module.name))
+      )
+      .map(dep =>
+        dep.copy(exclusions = exclusionsAdd(dep.exclusions, exclusions))
+      )
+  }
+
+  /**
+   * Get the dependencies of `project`, knowing that it came from dependency `from` (that is,
+   * `from.module == project.module`).
+   *
+   * Substitute properties, update scopes, apply exclusions, and get extra parameters from
+   * dependency management along the way.
+   */
+  def finalDependencies(from: Dependency,
+                        project: Project): Seq[Dependency] = {
+
+    // Here, we're substituting properties also in dependencies that come from parents
+    // or dependency management. This may not be the right thing to do.
+
+    val deps =
+      withExclusions(
+        withProperties(
+          depsWithDependencyManagement(
+            project.dependencies,
+            project.dependencyManagement
+          ),
+          mergeProperties(
+            project.properties,
+            Map(
+              "project.groupId" -> project.module.organization,
+              "project.artifactId" -> project.module.name,
+              "project.version" -> project.module.version
+            )
+          )
+        ),
+        from.exclusions
+      )
+      .map(withDefaultScope)
+
+    deps.flatMap { trDep =>
+      resolveScope(from.scope, trDep.scope)
+        .map(scope => trDep.copy(scope = scope, optional = trDep.optional || from.optional))
+    }
+  }
+
+  /**
+   * State of a dependency resolution.
+   *
+   * Done if `isDone` is `true`.
+   *
+   * @param dependencies: current set of dependencies
+   * @param conflicts: conflicting dependencies
+   * @param projectsCache: cache of known projects
+   * @param errors: keeps track of the modules whose project definition could not be found
+   */
+  case class Resolution(rootDependencies: Set[Dependency],
+                        dependencies: Set[Dependency],
+                        conflicts: Set[Dependency],
+                        projectsCache: Map[Module, (Repository, Project)],
+                        errors: Map[Module, Seq[String]],
+                        filter: Option[Dependency => Boolean],
+                        profileActivation: Option[(String, Activation, Map[String, String]) => Boolean]) {
+
+    /**
+     * Transitive dependencies of the current dependencies, according to what there currently is in cache.
+     * No attempt is made to solve version conflicts here.
+     */
+    def transitiveDependencies =
+      for {
+        dep <- (dependencies -- conflicts).toList
+        (_, proj) <- projectsCache.get(dep.module).toSeq
+        trDep <- finalDependencies(dep, proj).filter(filter getOrElse defaultFilter)
+      } yield trDep
+
+    /**
+     * The "next" dependency set, made of the current dependencies and their transitive dependencies,
+     * trying to solve version conflicts. Transitive dependencies are calculated with the current cache.
+     *
+     * Returns a tuple made of the conflicting dependencies, and all the dependencies.
+     */
+    def nextDependenciesAndConflicts = {
+      merge(dependencies ++ transitiveDependencies)
+    }
+
+    /**
+     * The modules we miss some info about.
+     */
+    def missingFromCache: Set[Module] = {
+      val modules = dependencies.map(_.module)
+      val nextModules = nextDependenciesAndConflicts._2.map(_.module)
+
+      (modules ++ nextModules)
+        .filterNot(mod => projectsCache.contains(mod) || errors.contains(mod))
+    }
+
+
+    /**
+     * Whether the resolution is done.
+     */
+    def isDone: Boolean = {
+      def isFixPoint = {
+        val (nextConflicts, nextDependencies) = nextDependenciesAndConflicts
+        dependencies == (nextDependencies ++ nextConflicts).toSet && conflicts == nextConflicts.toSet
+      }
+
+      missingFromCache.isEmpty && isFixPoint
+    }
+
+    private def key(dep: Dependency) =
+      (dep.module.organization, dep.module.name, dep.scope)
+
+    /**
+     * Returns a map giving the dependency that brought each of the dependency of the "next" dependency set,
+     * along with the exclusions that the source dependency adds to it.
+     */
+    def reverseDependenciesAndExclusions = {
+      val (updatedConflicts, updatedDeps) = nextDependenciesAndConflicts
+
+      val trDepsSeq =
+        for {
+          dep <- updatedDeps
+          (_, proj) <- projectsCache.get(dep.module).toList
+          trDep <- finalDependencies(dep, proj).filter(filter getOrElse defaultFilter)
+        } yield key(trDep) -> (key(dep), trDep.exclusions)
+
+      val knownDeps = (updatedDeps ++ updatedConflicts).map(key).toSet
+
+      trDepsSeq
+        .groupBy(_._1)
+        .mapValues(_.map(_._2).toVector)
+        .filterKeys(knownDeps)
+        .toList.toMap // Eagerly evaluate filterKeys/mapValues
+    }
+
+    /**
+     * Returns a map, whose keys are the dependencies from the "next" dependency set,
+     * filtering out those that are no more required, and whose values are the exclusions
+     * added to them by the dependencies that brought them here.
+     */
+    def remainingDependenciesAndExclusions = {
+      val rootDependenciesExclusions = rootDependencies
+        .map(dep => key(dep) -> dep.exclusions)
+        .toMap
+
+      type D = (String, String, Scope)
+
+      @tailrec
+      def helper[T](reverseDeps: Map[D, Vector[(D, T)]]): Map[D, Vector[(D, T)]] = {
+        val (toRemove, remaining) = reverseDeps.partition(kv => kv._2.isEmpty && !rootDependenciesExclusions.contains(kv._1))
+
+        if (toRemove.isEmpty) reverseDeps
+        else helper(remaining.mapValues(_.filter(x => remaining.contains(x._1) || rootDependenciesExclusions.contains(x._1))).toList.toMap)
+      }
+
+      val filteredReverseDependenciesAndExclusions = helper(reverseDependenciesAndExclusions)
+
+      (rootDependenciesExclusions.keySet ++ filteredReverseDependenciesAndExclusions.keySet)
+        .toList
+        .map{case dep => dep ->
+          (filteredReverseDependenciesAndExclusions.get(dep).map(_.map(_._2)).getOrElse(Nil) ++ rootDependenciesExclusions.get(dep))
+            .reduce(exclusionsIntersect)
+        }
+        .toMap
+    }
+
+    /**
+     * The final next dependency set, stripped of no more required ones.
+     */
+    def newDependencies = {
+      val remainingDeps0 = remainingDependenciesAndExclusions
+      nextDependenciesAndConflicts._2
+        .filter(dep => remainingDeps0.contains(key(dep)))
+        .map(dep => dep.copy(exclusions = remainingDeps0(key(dep))))
+        .toSet
+    }
+
+    private def nextNoMissingUnsafe(): Resolution = {
+      val (newConflicts, _) = nextDependenciesAndConflicts
+      copy(dependencies = newDependencies ++ newConflicts, conflicts = newConflicts.toSet)
+    }
+
+    /**
+     * If no module info is missing, the next state of the resolution, which can be immediately calculated.
+     * Else, the current resolution itself.
+     */
+    def nextIfNoMissing(): Resolution = {
+      val missing = missingFromCache
+      if (missing.isEmpty) nextNoMissingUnsafe()
+      else this
+    }
+
+    /**
+     * Do a new iteration, fetching the missing modules along the way.
+     */
+    def next(fetchModule: Module => EitherT[Task, List[String], (Repository, Project)]): Task[Resolution] = {
+      val missing = missingFromCache
+      if (missing.isEmpty) Task.now(nextNoMissingUnsafe())
+      else fetch(missing.toList, fetchModule).map(_.nextIfNoMissing())
+    }
+
+    /**
+     * Required modules for the dependency management of `project`.
+     */
+    def dependencyManagementRequirements(project: Project): Set[Module] = {
+      val approxProperties =
+        project.parent
+          .flatMap(projectsCache.get)
+          .map(_._2.properties)
+          .fold(project.properties)(mergeProperties(project.properties, _))
+
+      val profileDependencies =
+        profiles(project, approxProperties, profileActivation getOrElse defaultProfileActivation)
+          .flatMap(_.dependencies)
+
+      val modules =
+        (project.dependencies ++ profileDependencies)
+          .collect{ case dep if dep.scope == Scope.Import => dep.module } ++
+        project.parent
+
+      modules.toSet
+    }
+
+    /**
+     * Missing modules in cache, to get the full list of dependencies of `project`, taking
+     * dependency management / inheritance into account.
+     * 
+     * Note that adding the missing modules to the cache may unveil other missing modules, so
+     * these modules should be added to the cache, and `dependencyManagementMissing` checked again
+     * for new missing modules.
+     */
+    def dependencyManagementMissing(project: Project): Set[Module] = {
+
+      @tailrec
+      def helper(toCheck: Set[Module],
+                 done: Set[Module],
+                 missing: Set[Module]): Set[Module] = {
+
+        if (toCheck.isEmpty) missing
+        else if (toCheck.exists(done)) helper(toCheck -- done, done, missing)
+        else if (toCheck.exists(missing)) helper(toCheck -- missing, done, missing)
+        else if (toCheck.exists(projectsCache.contains)) {
+          val (checking, remaining) = toCheck.partition(projectsCache.contains)
+          val directRequirements = checking.flatMap(mod => dependencyManagementRequirements(projectsCache(mod)._2))
+
+          helper(remaining ++ directRequirements, done ++ checking, missing)
+        } else if (toCheck.exists(errors.contains)) {
+          val (errored, remaining) = toCheck.partition(errors.contains)
+          helper(remaining, done ++ errored, missing)
+        } else
+          helper(Set.empty, done, missing ++ toCheck)
+      }
+
+      helper(dependencyManagementRequirements(project), Set(project.module), Set.empty)
+    }
+
+    /**
+     * Add dependency management / inheritance related items to `project`, from what's available in cache.
+     * It is recommended to have fetched what `dependencyManagementMissing` returned prior to calling
+     * `withDependencyManagement`.
+     */
+    def withDependencyManagement(project: Project): Project = {
+      
+      val approxProperties =
+        project.parent
+          .filter(projectsCache.contains)
+          .map(projectsCache(_)._2.properties)
+          .fold(project.properties)(mergeProperties(project.properties, _))
+
+      val profiles0 = profiles(project, approxProperties, profileActivation getOrElse defaultProfileActivation)
+
+      val dependencies0 = addDependencies(project.dependencies +: profiles0.map(_.dependencies))
+      val properties0 = (project.properties /: profiles0)((acc, p) => mergeProperties(acc, p.properties))
+
+      val deps =
+        dependencies0
+          .collect{ case dep if dep.scope == Scope.Import && projectsCache.contains(dep.module) => dep.module } ++
+          project.parent.filter(projectsCache.contains)
+      val projs = deps.map(projectsCache(_)._2)
+
+      val depMgmt =
+        (project.dependencyManagement +: (profiles0.map(_.dependencyManagement) ++ projs.map(_.dependencyManagement)))
+          .foldLeft(Map.empty[DepMgmtKey, Dependency])(dependencyManagementAddSeq)
+
+      val depsSet = deps.toSet
+
+      project.copy(
+        dependencies = dependencies0
+          .filterNot(dep => dep.scope == Scope.Import && depsSet(dep.module)) ++
+          project.parent
+            .filter(projectsCache.contains)
+            .toSeq
+            .flatMap(projectsCache(_)._2.dependencies),
+        dependencyManagement = depMgmt.values.toSeq,
+        properties = project.parent
+          .filter(projectsCache.contains)
+          .map(projectsCache(_)._2.properties)
+          .fold(properties0)(mergeProperties(properties0, _))
+      )
+    }
+
+    /**
+     * Fetch `modules` with `fetchModules`, and add the resulting errors and projects to the cache.
+     */
+    def fetch(modules: Seq[Module],
+              fetchModule: Module => EitherT[Task, List[String], (Repository, Project)]): Task[Resolution] = {
+
+      val lookups = modules.map(dep => fetchModule(dep).run.map(dep -> _))
+      val gatheredLookups = Task.gatherUnordered(lookups, exceptionCancels = true)
+      gatheredLookups.flatMap{ lookupResults =>
+        val errors0 = errors ++ lookupResults.collect{case (mod, -\/(repoErrors)) => mod -> repoErrors}
+        val newProjects = lookupResults.collect{case (mod, \/-(proj)) => mod -> proj}
+
+        /*
+         * newProjects are project definitions, fresh from the repositories. We need to add
+         * dependency management / inheritance-related bits to them.
+         */
+
+        newProjects.foldLeft(Task.now(copy(errors = errors0))) { case (accTask, (mod, (repo, proj))) =>
+          for {
+            current <- accTask
+            updated <- current.fetch(current.dependencyManagementMissing(proj).toList, fetchModule)
+            proj0 = updated.withDependencyManagement(proj)
+          } yield updated.copy(projectsCache = updated.projectsCache + (proj0.module -> (repo, proj0)))
+        }
+      }
+    }
+
+  }
+
+  /**
+   * Default function checking whether a profile is active, given its id, activation conditions,
+   * and the properties of its project.
+   */
+  def defaultProfileActivation(id: String,
+                               activation: Activation,
+                               props: Map[String, String]): Boolean = {
+
+    if (activation.properties.isEmpty) false
+    else {
+      activation.properties.forall { case (name, valueOpt) =>
+        props.get(name).exists{ v =>
+          valueOpt.forall { reqValue =>
+            if (reqValue.startsWith("!")) v != reqValue.drop(1)
+            else v == reqValue
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Default dependency filter used during resolution.
+   *
+   * Only follows compile scope / non-optional dependencies.
+   */
+  def defaultFilter(dep: Dependency): Boolean =
+    !dep.optional && dep.scope == Scope.Compile
+
+  /**
+   * Get all the transitive dependencies of `dependencies`, solving any dependency version mismatch.
+   *
+   * Iteratively fetches the missing info of the current dependencies / add newly discovered dependencies
+   * to the current ones. The maximum number of such iterations can be bounded with `maxIterations`.
+   *
+   * ...
+   *
+   */
+  def resolve(dependencies: Set[Dependency],
+              fetch: Module => EitherT[Task, List[String], (Repository, Project)],
+              maxIterations: Option[Int],
+              filter: Option[Dependency => Boolean],
+              profileActivation: Option[(String, Activation, Map[String, String]) => Boolean]): Task[Resolution] = {
+
+    val dependencies0 = dependencies.map(withDefaultScope)
+
+    val startResolution = Resolution(
+      dependencies0, dependencies0, Set.empty,
+      Map.empty, Map.empty,
+      filter,
+      profileActivation
+    )
+
+    def helper(resolution: Resolution, remainingIter: Option[Int]): Task[(Resolution, Option[Int])] = {
+      if (resolution.isDone || remainingIter.exists(_ <= 0))
+        Task.now((resolution, remainingIter))
+      else
+        resolution.next(fetch).flatMap(helper(_, remainingIter.map(_ - 1)))
+    }
+
+    helper(startResolution, maxIterations).map(_._1)
+  }
+
+}
diff --git a/core/src/main/scala/coursier/core/Version.scala b/core/src/main/scala/coursier/core/Version.scala
new file mode 100644
index 000000000..5a970d0bb
--- /dev/null
+++ b/core/src/main/scala/coursier/core/Version.scala
@@ -0,0 +1,104 @@
+package coursier.core
+
+import coursier.core.compatibility._
+
+case class Versions(latest: String,
+                    release: String,
+                    available: List[String],
+                    lastUpdated: Option[DateTime])
+
+/** Used internally by Resolver */
+case class Version(repr: String) extends Ordered[Version] {
+
+  lazy val cmp = ComparableVersion.parse(repr)
+
+  def compare(other: Version): Int = {
+    cmp.compare(other.cmp)
+  }
+}
+
+case class VersionInterval(from: Option[Version],
+                           to: Option[Version],
+                           fromIncluded: Boolean,
+                           toIncluded: Boolean) {
+
+  def isValid: Boolean = {
+    val fromToOrder =
+      for {
+        f <- from
+        t <- to
+        cmd = f.compare(t)
+      } yield cmd < 0 || (cmd == 0 && fromIncluded && toIncluded)
+
+    fromToOrder.forall(x => x) && (from.nonEmpty || !fromIncluded) && (to.nonEmpty || !toIncluded)
+  }
+
+  def merge(other: VersionInterval): Option[VersionInterval] = {
+    val (newFrom, newFromIncluded) =
+      (from, other.from) match {
+        case (Some(a), Some(b)) =>
+          val cmp = a.compare(b)
+          if (cmp < 0) (Some(b), other.fromIncluded)
+          else if (cmp > 0) (Some(a), fromIncluded)
+          else (Some(a), fromIncluded && other.fromIncluded)
+
+        case (Some(a), None) => (Some(a), fromIncluded)
+        case (None, Some(b)) => (Some(b), other.fromIncluded)
+        case (None, None) => (None, false)
+      }
+
+    val (newTo, newToIncluded) =
+      (to, other.to) match {
+        case (Some(a), Some(b)) =>
+          val cmp = a.compare(b)
+          if (cmp < 0) (Some(a), toIncluded)
+          else if (cmp > 0) (Some(b), other.toIncluded)
+          else (Some(a), toIncluded && other.toIncluded)
+
+        case (Some(a), None) => (Some(a), toIncluded)
+        case (None, Some(b)) => (Some(b), other.toIncluded)
+        case (None, None) => (None, false)
+      }
+
+    Some(VersionInterval(newFrom, newTo, newFromIncluded, newToIncluded))
+      .filter(_.isValid)
+  }
+
+  def constraint: VersionConstraint =
+    this match {
+      case VersionInterval.zero => VersionConstraint.None
+      case VersionInterval(Some(version), None, true, false) => VersionConstraint.Preferred(version)
+      case itv => VersionConstraint.Interval(itv)
+    }
+
+  def repr: String = Seq(
+    if (fromIncluded) "[" else "(",
+    from.map(_.repr).mkString,
+    ",",
+    to.map(_.repr).mkString,
+    if (toIncluded) "]" else ")"
+  ).mkString
+}
+
+object VersionInterval {
+  val zero = VersionInterval(None, None, fromIncluded = false, toIncluded = false)
+}
+
+sealed trait VersionConstraint {
+  def interval: VersionInterval
+  def repr: String
+}
+object VersionConstraint {
+  /** Currently treated as minimum... */
+  case class Preferred(version: Version) extends VersionConstraint {
+    def interval: VersionInterval = VersionInterval(Some(version), Option.empty, fromIncluded = true, toIncluded = false)
+    def repr: String = version.repr
+  }
+  case class Interval(interval: VersionInterval) extends VersionConstraint {
+    def repr: String = interval.repr
+  }
+  case object None extends VersionConstraint {
+    val interval = VersionInterval.zero
+    def repr: String = "" // Once parsed, "(,)" becomes "" because of this
+  }
+}
\ No newline at end of file
diff --git a/core/src/main/scala/coursier/core/Xml.scala b/core/src/main/scala/coursier/core/Xml.scala
new file mode 100644
index 000000000..4449985de
--- /dev/null
+++ b/core/src/main/scala/coursier/core/Xml.scala
@@ -0,0 +1,247 @@
+package coursier.core
+
+import coursier.core.compatibility.DateTime
+
+import scalaz._
+
+object Xml {
+
+  /** A representation of an XML node/document, with different implementations on the JVM and JS */
+  trait Node {
+    def label: String
+    def child: Seq[Node]
+    def isText: Boolean
+    def textContent: String
+    def isElement: Boolean
+  }
+
+  object Node {
+    val empty: Node =
+      new Node {
+        val isText = false
+        val isElement = false
+        val child = Nil
+        val label = ""
+        val textContent = ""
+      }
+  }
+
+  object Text {
+    def unapply(n: Node): Option[String] =
+      if (n.isText) Some(n.textContent)
+      else None
+  }
+
+  private def text(elem: Node, label: String, description: String) = {
+    import Scalaz.ToOptionOpsFromOption
+
+    elem.child
+      .find(_.label == label)
+      .flatMap(_.child.collectFirst{case Text(t) => t})
+      .toRightDisjunction(s"$description not found")
+  }
+
+  private def property(elem: Node): String \/ (String, String) = {
+    elem.child match {
+      case Seq() => \/-(elem.label -> "")
+      case Seq(Text(t)) => \/-(elem.label -> t)
+      case _ => -\/(s"Can't parse property $elem")
+    }
+  }
+
+  // TODO Allow no version in some contexts
+  private def module(node: Node, groupIdIsOptional: Boolean = false): String \/ Module = {
+    for {
+      organization <- {
+        val e = text(node, "groupId", "Organization")
+        if (groupIdIsOptional) e.orElse(\/-(""))
+        else e
+      }
+      name <- text(node, "artifactId", "Name")
+      version = text(node, "version", "Version").getOrElse("")
+    } yield Module(organization, name, version).trim
+  }
+
+  private val defaultScope = Scope.Other("")
+  private val defaultType = "jar"
+  private val defaultClassifier = ""
+
+  def dependency(node: Node): String \/ Dependency = {
+    for {
+      mod <- module(node)
+      scopeOpt = text(node, "scope", "").toOption
+        .map(Parse.scope)
+      typeOpt = text(node, "type", "").toOption
+      classifierOpt = text(node, "classifier", "").toOption
+      xmlExclusions = node.child
+        .find(_.label == "exclusions")
+        .map(_.child.filter(_.label == "exclusion"))
+        .getOrElse(Seq.empty)
+      exclusions <- {
+        import Scalaz._
+        xmlExclusions.toList.traverseU(module(_))
+      }
+      optional = text(node, "optional", "").toOption.toSeq.contains("true")
+    } yield Dependency(
+        mod,
+        scopeOpt getOrElse defaultScope,
+        typeOpt getOrElse defaultType,
+        classifierOpt getOrElse defaultClassifier,
+        exclusions.map(mod => (mod.organization, mod.name)).toSet,
+        optional
+      )
+  }
+
+  private def profileActivation(node: Node): (Option[Boolean], Activation) = {
+    val byDefault =
+      text(node, "activeByDefault", "").toOption.flatMap{
+        case "true" => Some(true)
+        case "false" => Some(false)
+        case _ => None
+      }
+
+    val properties = node.child
+      .filter(_.label == "property")
+      .flatMap{ p =>
+        for{
+          name <- text(p, "name", "").toOption
+          valueOpt = text(p, "value", "").toOption
+        } yield (name, valueOpt)
+      }
+
+    (byDefault, Activation(properties))
+  }
+
+  def profile(node: Node): String \/ Profile = {
+    import Scalaz._
+
+    for {
+      id <- text(node, "id", "Profile ID")
+
+      xmlActivationOpt = node.child
+        .find(_.label == "activation")
+      (activeByDefault, activation) = xmlActivationOpt.fold((Option.empty[Boolean], Activation(Nil)))(profileActivation)
+
+      xmlDeps = node.child
+        .find(_.label == "dependencies")
+        .map(_.child.filter(_.label == "dependency"))
+        .getOrElse(Seq.empty)
+      deps <- xmlDeps.toList.traverseU(dependency)
+
+      xmlDepMgmts = node.child
+        .find(_.label == "dependencyManagement")
+        .flatMap(_.child.find(_.label == "dependencies"))
+        .map(_.child.filter(_.label == "dependency"))
+        .getOrElse(Seq.empty)
+      depMgmts <- xmlDepMgmts.toList.traverseU(dependency)
+
+      xmlProperties = node.child
+        .find(_.label == "properties")
+        .map(_.child.collect{case elem if elem.isElement => elem})
+        .getOrElse(Seq.empty)
+      properties <- {
+        import Scalaz._
+        xmlProperties.toList.traverseU(property)
+      }
+
+    } yield Profile(id, activeByDefault, activation, deps, depMgmts, properties.toMap)
+  }
+
+  def project(pom: Node): String \/ Project = {
+    import Scalaz._
+
+    for {
+      projModule <- module(pom, groupIdIsOptional = true)
+
+      parentOpt = pom.child
+        .find(_.label == "parent")
+      parentModuleOpt <- parentOpt
+        .map(module(_).map(Some(_)))
+        .getOrElse(\/-(None))
+
+      xmlDeps = pom.child
+        .find(_.label == "dependencies")
+        .map(_.child.filter(_.label == "dependency"))
+        .getOrElse(Seq.empty)
+      deps <- xmlDeps.toList.traverseU(dependency)
+
+      xmlDepMgmts = pom.child
+        .find(_.label == "dependencyManagement")
+        .flatMap(_.child.find(_.label == "dependencies"))
+        .map(_.child.filter(_.label == "dependency"))
+        .getOrElse(Seq.empty)
+      depMgmts <- xmlDepMgmts.toList.traverseU(dependency)
+
+      groupId <- Some(projModule.organization).filter(_.nonEmpty)
+        .orElse(parentModuleOpt.map(_.organization).filter(_.nonEmpty))
+        .toRightDisjunction("No organization found")
+      version <- Some(projModule.version).filter(_.nonEmpty)
+        .orElse(parentModuleOpt.map(_.version).filter(_.nonEmpty))
+        .toRightDisjunction("No version found")
+
+      _ <- parentModuleOpt
+        .map(mod => if (mod.version.isEmpty) -\/("Parent version missing") else \/-(()))
+        .getOrElse(\/-(()))
+      _ <- parentModuleOpt
+        .map(mod => if (mod.organization.isEmpty) -\/("Parent organization missing") else \/-(()))
+        .getOrElse(\/-(()))
+
+      xmlProperties = pom.child
+        .find(_.label == "properties")
+        .map(_.child.collect{case elem if elem.isElement => elem})
+        .getOrElse(Seq.empty)
+      properties <- xmlProperties.toList.traverseU(property)
+
+      xmlProfiles = pom.child
+        .find(_.label == "profiles")
+        .map(_.child.filter(_.label == "profile"))
+        .getOrElse(Seq.empty)
+      profiles <- xmlProfiles.toList.traverseU(profile)
+
+    } yield Project(
+      projModule.copy(organization = groupId, version = version),
+      deps,
+      parentModuleOpt,
+      depMgmts,
+      properties.toMap,
+      profiles
+    )
+  }
+
+  def versions(node: Node): String \/ Versions = {
+    import Scalaz._
+
+    for {
+      organization <- text(node, "groupId", "Organization") // Ignored
+      name <- text(node, "artifactId", "Name") // Ignored
+
+      xmlVersioning <- node.child
+        .find(_.label == "versioning")
+        .toRightDisjunction("Versioning info not found in metadata")
+
+      latest = text(xmlVersioning, "latest", "Latest version")
+        .getOrElse("")
+      release = text(xmlVersioning, "release", "Release version")
+        .getOrElse("")
+
+      versions <- xmlVersioning.child
+        .find(_.label == "versions")
+        .map(_.child.filter(_.label == "version").flatMap(_.child.collectFirst{case Text(t) => t}))
+        .toRightDisjunction("Version list not found in metadata")
+
+      lastUpdatedOpt = text(xmlVersioning, "lastUpdated", "Last update date and time")
+        .toOption
+        .filter(s => s.length == 14 && s.forall(_.isDigit))
+        .map(s => DateTime(
+          s.substring(0, 4).toInt,
+          s.substring(4, 6).toInt,
+          s.substring(6, 8).toInt,
+          s.substring(8, 10).toInt,
+          s.substring(10, 12).toInt,
+          s.substring(12, 14).toInt
+        ))
+
+    } yield Versions(latest, release, versions.toList, lastUpdatedOpt)
+  }
+
+}
diff --git a/core/src/main/scala/coursier/package.scala b/core/src/main/scala/coursier/package.scala
new file mode 100644
index 000000000..86394a5e7
--- /dev/null
+++ b/core/src/main/scala/coursier/package.scala
@@ -0,0 +1,79 @@
+import scalaz.EitherT
+import scalaz.concurrent.Task
+
+package object coursier {
+
+  type Dependency = core.Dependency
+  object Dependency {
+    def apply(module: Module,
+              scope: Scope = Scope.Other(""), // Subsituted by Resolver with its own default scope (compile)
+              `type`: String = "jar",
+              classifier: String = "",
+              exclusions: Set[(String, String)] = Set.empty,
+              optional: Boolean = false): Dependency =
+      core.Dependency(module, scope, `type`, classifier, exclusions, optional)
+  }
+
+  type Project = core.Project
+  object Project {
+    def apply(module: Module,
+              dependencies: Seq[Dependency] = Seq.empty,
+              parent: Option[Module] = None,
+              dependencyManagement: Seq[Dependency] = Seq.empty,
+              properties: Map[String, String] = Map.empty,
+              profiles: Seq[Profile] = Seq.empty): Project =
+      core.Project(module, dependencies, parent, dependencyManagement, properties, profiles)
+  }
+
+  type Profile = core.Profile
+  object Profile {
+    type Activation = core.Activation
+    object Activation {
+      def apply(properties: Seq[(String, Option[String])] = Nil): Activation =
+        core.Activation(properties)
+    }
+
+    def apply(id: String,
+              activeByDefault: Option[Boolean] = None,
+              activation: Activation = Activation(),
+              dependencies: Seq[Dependency] = Nil,
+              dependencyManagement: Seq[Dependency] = Nil,
+              properties: Map[String, String] = Map.empty) =
+      core.Profile(id, activeByDefault, activation, dependencies, dependencyManagement, properties)
+  }
+
+  type Module = core.Module
+  object Module {
+    def apply(organization: String, name: String, version: String): Module =
+      core.Module(organization, name, version)
+  }
+
+  type Scope = core.Scope
+  val Scope: core.Scope.type = core.Scope
+
+  type Repository = core.Repository
+
+  def fetchFrom(repositories: Seq[Repository]): Module => EitherT[Task, List[String], (Repository, Project)] =
+    core.Resolver.find(repositories, _)
+
+  type Resolution = core.Resolver.Resolution
+  object Resolution {
+    val empty = apply()
+    def apply(rootDependencies: Set[Dependency] = Set.empty,
+              dependencies: Set[Dependency] = Set.empty,
+              conflicts: Set[Dependency] = Set.empty,
+              projectsCache: Map[Module, (Repository, Project)] = Map.empty,
+              errors: Map[Module, Seq[String]] = Map.empty,
+              filter: Option[Dependency => Boolean] = None,
+              profileActivation: Option[(String, Profile.Activation, Map[String, String]) => Boolean] = None): Resolution =
+      core.Resolver.Resolution(rootDependencies, dependencies, conflicts, projectsCache, errors, filter, profileActivation)
+  }
+
+  def resolve(dependencies: Set[Dependency],
+              fetch: Module => EitherT[Task, List[String], (Repository, Project)],
+              maxIterations: Option[Int] = Some(200),
+              filter: Option[Dependency => Boolean] = None,
+              profileActivation: Option[(String, Profile.Activation, Map[String, String]) => Boolean] = None): Task[Resolution] = {
+    core.Resolver.resolve(dependencies, fetch, maxIterations, filter, profileActivation)
+  }
+}
diff --git a/core/src/test/scala/coursier/test/CentralTests.scala b/core/src/test/scala/coursier/test/CentralTests.scala
new file mode 100644
index 000000000..ec8d65721
--- /dev/null
+++ b/core/src/test/scala/coursier/test/CentralTests.scala
@@ -0,0 +1,42 @@
+package coursier
+package test
+
+import utest._
+import scala.async.Async.{async, await}
+
+import coursier.test.compatibility._
+
+object CentralTests extends TestSuite {
+
+  val repositories = Seq[Repository](
+    repository.mavenCentral
+  )
+
+  val tests = TestSuite {
+    'logback{
+      async {
+        val dep = Dependency(Module("ch.qos.logback", "logback-classic", "1.1.3"))
+        val res0 =
+          await(resolve(Set(dep), fetchFrom(repositories))
+            .runF)
+
+        val res = res0.copy(
+          projectsCache = Map.empty, errors = Map.empty, // No validating these here
+          dependencies = res0.dependencies.filter(dep => dep.scope == Scope.Compile && !dep.optional)
+        )
+
+        val expected = Resolution(
+          rootDependencies = Set(dep.withCompileScope),
+          dependencies = Set(
+            dep.withCompileScope,
+            Dependency(Module("ch.qos.logback", "logback-core", "1.1.3")).withCompileScope,
+            Dependency(Module("org.slf4j", "slf4j-api", "1.7.7")).withCompileScope
+          )
+        )
+
+        assert(res == expected)
+      }
+    }
+  }
+
+}
diff --git a/core/src/test/scala/coursier/test/ComparableVersionTests.scala b/core/src/test/scala/coursier/test/ComparableVersionTests.scala
new file mode 100644
index 000000000..d86dd6450
--- /dev/null
+++ b/core/src/test/scala/coursier/test/ComparableVersionTests.scala
@@ -0,0 +1,343 @@
+package coursier
+package test
+
+import java.util.Locale
+
+import utest._
+
+object ComparableVersionTests extends TestSuite {
+  import core.ComparableVersion.parse
+
+  def compare(first: String, second: String) = parse(first).compare(parse(second))
+
+  def increasing(versions: String*): Boolean =
+    versions.iterator.sliding(2).withPartial(false).forall{case Seq(a, b) => compare(a, b) < 0 }
+
+  val tests = TestSuite {
+    'stackOverflow{
+      val s = "." * 100000
+      val v = parse(s)
+      assert(v.isEmpty)
+    }
+
+    'empty{
+      val v0 = parse("0")
+      val v = parse("")
+
+      assert(v0.isEmpty)
+      assert(v.isEmpty)
+    }
+
+    'numericOrdering{
+      assert(compare("1.2", "1.10") < 0)
+    }
+
+    // Adapted from aether-core/aether-util/src/test/java/org/eclipse/aether/util/version/GenericVersionTest.java
+    // Only one test doesn't pass (see FIXME below)
+
+    'EmptyVersion{
+      assert(compare("0", "" ) == 0)
+    }
+
+
+
+    'NumericOrdering
+    {
+      assert(compare("2", "10" ) < 0)
+      assert(compare("1.2", "1.10" ) < 0)
+      assert(compare("1.0.2", "1.0.10" ) < 0)
+      assert(compare("1.0.0.2", "1.0.0.10" ) < 0)
+      assert(compare("1.0.20101206.111434.1", "1.0.20101206.111435.1" ) < 0)
+      assert(compare("1.0.20101206.111434.2", "1.0.20101206.111434.10" ) < 0)
+    }
+
+
+    'Delimiters
+    {
+      assert(compare("1.0", "1-0" ) == 0)
+      assert(compare("1.0", "1_0" ) == 0)
+      assert(compare("1.a", "1a" ) == 0)
+    }
+
+
+    'LeadingZerosAreSemanticallyIrrelevant
+    {
+      assert(compare("1", "01" ) == 0)
+      assert(compare("1.2", "1.002" ) == 0)
+      assert(compare("1.2.3", "1.2.0003" ) == 0)
+      assert(compare("1.2.3.4", "1.2.3.00004" ) == 0)
+    }
+
+
+    'TrailingZerosAreSemanticallyIrrelevant
+    {
+      assert(compare("1", "1.0.0.0.0.0.0.0.0.0.0.0.0.0" ) == 0)
+      assert(compare("1", "1-0-0-0-0-0-0-0-0-0-0-0-0-0" ) == 0)
+      assert(compare("1", "1.0-0.0-0.0-0.0-0.0-0.0-0.0" ) == 0)
+      assert(compare("1", "1.0000000000000" ) == 0)
+      assert(compare("1.0", "1.0.0" ) == 0)
+    }
+
+
+    'TrailingZerosBeforeQualifierAreSemanticallyIrrelevant
+    {
+      assert(compare("1.0-ga", "1.0.0-ga" ) == 0)
+      assert(compare("1.0.ga", "1.0.0.ga" ) == 0)
+      assert(compare("1.0ga", "1.0.0ga" ) == 0)
+
+      assert(compare("1.0-alpha", "1.0.0-alpha" ) == 0)
+      assert(compare("1.0.alpha", "1.0.0.alpha" ) == 0)
+      assert(compare("1.0alpha", "1.0.0alpha" ) == 0)
+      assert(compare("1.0-alpha-snapshot", "1.0.0-alpha-snapshot" ) == 0)
+      assert(compare("1.0.alpha.snapshot", "1.0.0.alpha.snapshot" ) == 0)
+
+      assert(compare("1.x.0-alpha", "1.x.0.0-alpha" ) == 0)
+      assert(compare("1.x.0.alpha", "1.x.0.0.alpha" ) == 0)
+      assert(compare("1.x.0-alpha-snapshot", "1.x.0.0-alpha-snapshot" ) == 0)
+      assert(compare("1.x.0.alpha.snapshot", "1.x.0.0.alpha.snapshot" ) == 0)
+    }
+
+
+    'TrailingDelimitersAreSemanticallyIrrelevant
+    {
+      assert(compare("1", "1............." ) == 0)
+      assert(compare("1", "1-------------" ) == 0)
+      assert(compare("1.0", "1............." ) == 0)
+      assert(compare("1.0", "1-------------" ) == 0)
+    }
+
+
+    'InitialDelimiters
+    {
+      assert(compare("0.1", ".1" ) == 0)
+      assert(compare("0.0.1", "..1" ) == 0)
+      assert(compare("0.1", "-1" ) == 0)
+      assert(compare("0.0.1", "--1" ) == 0)
+    }
+
+
+    'ConsecutiveDelimiters
+    {
+      assert(compare("1.0.1", "1..1" ) == 0)
+      assert(compare("1.0.0.1", "1...1" ) == 0)
+      assert(compare("1.0.1", "1--1" ) == 0)
+      assert(compare("1.0.0.1", "1---1" ) == 0)
+    }
+
+
+    'UnlimitedNumberOfVersionComponents
+    {
+      assert(compare("1.0.1.2.3.4.5.6.7.8.9.0.1.2.10", "1.0.1.2.3.4.5.6.7.8.9.0.1.2.3" ) > 0)
+    }
+
+
+    'UnlimitedNumberOfDigitsInNumericComponent
+    {
+      assert(compare("1.1234567890123456789012345678901", "1.123456789012345678901234567891" ) > 0)
+    }
+
+
+    'TransitionFromDigitToLetterAndViceVersaIsEqualivantToDelimiter
+    {
+      assert(compare("1alpha10", "1.alpha.10" ) == 0)
+      assert(compare("1alpha10", "1-alpha-10" ) == 0)
+
+      assert(compare("1.alpha10", "1.alpha2" ) > 0)
+      assert(compare("10alpha", "1alpha" ) > 0)
+    }
+
+
+    'WellKnownQualifierOrdering
+    {
+      assert(compare("1-alpha1", "1-a1" ) == 0)
+      assert(compare("1-alpha", "1-beta" ) < 0)
+      assert(compare("1-beta1", "1-b1" ) == 0)
+      assert(compare("1-beta", "1-milestone" ) < 0)
+      assert(compare("1-milestone1", "1-m1" ) == 0)
+      assert(compare("1-milestone", "1-rc" ) < 0)
+      assert(compare("1-rc", "1-cr" ) == 0)
+      assert(compare("1-rc", "1-snapshot" ) < 0)
+      assert(compare("1-snapshot", "1" ) < 0)
+      assert(compare("1", "1-ga" ) == 0)
+      assert(compare("1", "1.ga.0.ga" ) == 0)
+      assert(compare("1.0", "1-ga" ) == 0)
+      assert(compare("1", "1-ga.ga" ) == 0)
+      assert(compare("1", "1-ga-ga" ) == 0)
+      assert(compare("A", "A.ga.ga" ) == 0)
+      assert(compare("A", "A-ga-ga" ) == 0)
+      assert(compare("1", "1-final" ) == 0)
+      assert(compare("1", "1-sp" ) < 0)
+
+      assert(compare("A.rc.1", "A.ga.1" ) < 0)
+      assert(compare("A.sp.1", "A.ga.1" ) > 0)
+      assert(compare("A.rc.x", "A.ga.x" ) < 0)
+      assert(compare("A.sp.x", "A.ga.x" ) > 0)
+    }
+
+
+    'WellKnownQualifierVersusUnknownQualifierOrdering
+    {
+      assert(compare("1-abc", "1-alpha" ) > 0)
+      assert(compare("1-abc", "1-beta" ) > 0)
+      assert(compare("1-abc", "1-milestone" ) > 0)
+      assert(compare("1-abc", "1-rc" ) > 0)
+      assert(compare("1-abc", "1-snapshot" ) > 0)
+      assert(compare("1-abc", "1" ) > 0)
+      assert(compare("1-abc", "1-sp" ) > 0)
+    }
+
+
+    'WellKnownSingleCharQualifiersOnlyRecognizedIfImmediatelyFollowedByNumber
+    {
+      assert(compare("1.0a", "1.0" ) > 0)
+      assert(compare("1.0-a", "1.0" ) > 0)
+      assert(compare("1.0.a", "1.0" ) > 0)
+      assert(compare("1.0b", "1.0" ) > 0)
+      assert(compare("1.0-b", "1.0" ) > 0)
+      assert(compare("1.0.b", "1.0" ) > 0)
+      assert(compare("1.0m", "1.0" ) > 0)
+      assert(compare("1.0-m", "1.0" ) > 0)
+      assert(compare("1.0.m", "1.0" ) > 0)
+
+      assert(compare("1.0a1", "1.0" ) < 0)
+      assert(compare("1.0-a1", "1.0" ) < 0)
+      assert(compare("1.0.a1", "1.0" ) < 0)
+      assert(compare("1.0b1", "1.0" ) < 0)
+      assert(compare("1.0-b1", "1.0" ) < 0)
+      assert(compare("1.0.b1", "1.0" ) < 0)
+      assert(compare("1.0m1", "1.0" ) < 0)
+      assert(compare("1.0-m1", "1.0" ) < 0)
+      assert(compare("1.0.m1", "1.0" ) < 0)
+
+      assert(compare("1.0a.1", "1.0" ) > 0)
+      assert(compare("1.0a-1", "1.0" ) > 0)
+      assert(compare("1.0b.1", "1.0" ) > 0)
+      assert(compare("1.0b-1", "1.0" ) > 0)
+      assert(compare("1.0m.1", "1.0" ) > 0)
+      assert(compare("1.0m-1", "1.0" ) > 0)
+    }
+
+
+    'UnknownQualifierOrdering
+    {
+      assert(compare("1-abc", "1-abcd" ) < 0)
+      assert(compare("1-abc", "1-bcd" ) < 0)
+      assert(compare("1-abc", "1-aac" ) > 0)
+    }
+
+
+    'CaseInsensitiveOrderingOfQualifiers
+    {
+      assert(compare("1.alpha", "1.ALPHA" ) == 0)
+      assert(compare("1.alpha", "1.Alpha" ) == 0)
+
+      assert(compare("1.beta", "1.BETA" ) == 0)
+      assert(compare("1.beta", "1.Beta" ) == 0)
+
+      assert(compare("1.milestone", "1.MILESTONE" ) == 0)
+      assert(compare("1.milestone", "1.Milestone" ) == 0)
+
+      assert(compare("1.rc", "1.RC" ) == 0)
+      assert(compare("1.rc", "1.Rc" ) == 0)
+      assert(compare("1.cr", "1.CR" ) == 0)
+      assert(compare("1.cr", "1.Cr" ) == 0)
+
+      assert(compare("1.snapshot", "1.SNAPSHOT" ) == 0)
+      assert(compare("1.snapshot", "1.Snapshot" ) == 0)
+
+      assert(compare("1.ga", "1.GA" ) == 0)
+      assert(compare("1.ga", "1.Ga" ) == 0)
+      assert(compare("1.final", "1.FINAL" ) == 0)
+      assert(compare("1.final", "1.Final" ) == 0)
+
+      assert(compare("1.sp", "1.SP" ) == 0)
+      assert(compare("1.sp", "1.Sp" ) == 0)
+
+      assert(compare("1.unknown", "1.UNKNOWN" ) == 0)
+      assert(compare("1.unknown", "1.Unknown" ) == 0)
+    }
+
+
+    'QualifierVersusNumberOrdering
+    {
+      assert(compare("1-ga", "1-1" ) < 0)
+      assert(compare("1.ga", "1.1" ) < 0)
+      assert(compare("1-ga", "1.0" ) == 0)
+      assert(compare("1.ga", "1.0" ) == 0)
+
+      assert(compare("1-ga-1", "1-0-1" ) < 0)
+      assert(compare("1.ga.1", "1.0.1" ) < 0)
+
+      assert(compare("1.sp", "1.0" ) > 0)
+      assert(compare("1.sp", "1.1" ) < 0)
+
+      assert(compare("1-abc", "1-1" ) < 0)
+      assert(compare("1.abc", "1.1" ) < 0)
+
+      assert(compare("1-xyz", "1-1" ) < 0)
+      assert(compare("1.xyz", "1.1" ) < 0)
+    }
+
+
+
+    'MinimumSegment
+    {
+      assert(compare("1.min", "1.0-alpha-1" ) < 0)
+      assert(compare("1.min", "1.0-SNAPSHOT" ) < 0)
+      assert(compare("1.min", "1.0" ) < 0)
+      assert(compare("1.min", "1.9999999999" ) < 0)
+
+      assert(compare("1.min", "1.MIN" ) == 0)
+
+      assert(compare("1.min", "0.99999" ) > 0)
+      assert(compare("1.min", "0.max" ) > 0)
+    }
+
+
+    'MaximumSegment
+    {
+      assert(compare("1.max", "1.0-alpha-1" ) > 0)
+      assert(compare("1.max", "1.0-SNAPSHOT" ) > 0)
+      assert(compare("1.max", "1.0" ) > 0)
+      assert(compare("1.max", "1.9999999999" ) > 0)
+
+      assert(compare("1.max", "1.MAX" ) == 0)
+
+      assert(compare("1.max", "2.0-alpha-1" ) < 0)
+      assert(compare("1.max", "2.min" ) < 0)
+    }
+
+
+    'VersionEvolution
+    {
+      assert(increasing( "0.9.9-SNAPSHOT", "0.9.9", "0.9.10-SNAPSHOT", "0.9.10", "1.0-alpha-2-SNAPSHOT", "1.0-alpha-2",
+        "1.0-alpha-10-SNAPSHOT", "1.0-alpha-10", "1.0-beta-1-SNAPSHOT", "1.0-beta-1",
+        "1.0-rc-1-SNAPSHOT", "1.0-rc-1", "1.0-SNAPSHOT", "1.0", "1.0-sp-1-SNAPSHOT", "1.0-sp-1"))
+      // FIXME Should pass?
+      // assert(compare("1.0-sp-1", "1.0.1-alpha-1-SNAPSHOT") < 0)
+      assert(increasing("1.0.1-alpha-1-SNAPSHOT",
+      "1.0.1-alpha-1", "1.0.1-beta-1-SNAPSHOT", "1.0.1-beta-1",
+        "1.0.1-rc-1-SNAPSHOT", "1.0.1-rc-1", "1.0.1-SNAPSHOT", "1.0.1", "1.1-SNAPSHOT", "1.1" ))
+
+      assert(increasing( "1.0-alpha", "1.0", "1.0-1" ))
+      assert(increasing( "1.0.alpha", "1.0", "1.0-1" ))
+      assert(increasing( "1.0-alpha", "1.0", "1.0.1" ))
+      assert(increasing( "1.0.alpha", "1.0", "1.0.1" ))
+    }
+
+
+//    'CaseInsensitiveOrderingOfQualifiersIsLocaleIndependent
+//    {
+//      val orig = Locale.getDefault
+//      try {
+//        for ( locale <- Seq(Locale.ENGLISH, new Locale( "tr" )) ) {
+//          Locale.setDefault( locale )
+//          assert(compare("1-abcdefghijklmnopqrstuvwxyz", "1-ABCDEFGHIJKLMNOPQRSTUVWXYZ" ) == 0)
+//        }
+//      }
+//      finally Locale.setDefault( orig )
+//    }
+
+  }
+
+}
diff --git a/core/src/test/scala/coursier/test/ExclusionsTests.scala b/core/src/test/scala/coursier/test/ExclusionsTests.scala
new file mode 100644
index 000000000..906c95ab5
--- /dev/null
+++ b/core/src/test/scala/coursier/test/ExclusionsTests.scala
@@ -0,0 +1,124 @@
+package coursier
+package test
+
+import utest._
+import core.Resolver.{ exclusionsAdd, exclusionsIntersect }
+
+object ExclusionsTests extends TestSuite {
+
+  val tests = TestSuite {
+    val e1 = Set(("org1", "name1"))
+    val e2 = Set(("org2", "name2"))
+
+    val enb = Set(("org1", "*"))
+    val eob = Set(("*", "name1"))
+    val eb = Set(("*", "*"))
+
+    'add{
+      'basicZero{
+        val result1l = exclusionsAdd(e1, Set.empty)
+        val result1r = exclusionsAdd(Set.empty, e1)
+        val result2l = exclusionsAdd(e2, Set.empty)
+        val result2r = exclusionsAdd(Set.empty, e2)
+        assert(result1l == e1)
+        assert(result1r == e1)
+        assert(result2l == e2)
+        assert(result2r == e2)
+      }
+      'basic{
+        val expected = e1 ++ e2
+        val result12 = exclusionsAdd(e1, e2)
+        val result21 = exclusionsAdd(e2, e1)
+        assert(result12 == expected)
+        assert(result21 == expected)
+      }
+
+      'nameBlob{
+        val result1b = exclusionsAdd(e1, enb)
+        val resultb1 = exclusionsAdd(enb, e1)
+        val result2b = exclusionsAdd(e2, enb)
+        val resultb2 = exclusionsAdd(enb, e2)
+        assert(result1b == enb)
+        assert(resultb1 == enb)
+        assert(result2b == (e2 ++ enb))
+        assert(resultb2 == (e2 ++ enb))
+      }
+
+      'orgBlob{
+        val result1b = exclusionsAdd(e1, eob)
+        val resultb1 = exclusionsAdd(eob, e1)
+        val result2b = exclusionsAdd(e2, eob)
+        val resultb2 = exclusionsAdd(eob, e2)
+        assert(result1b == eob)
+        assert(resultb1 == eob)
+        assert(result2b == (e2 ++ eob))
+        assert(resultb2 == (e2 ++ eob))
+      }
+
+      'blob{
+        val result1b = exclusionsAdd(e1, eb)
+        val resultb1 = exclusionsAdd(eb, e1)
+        val result2b = exclusionsAdd(e2, eb)
+        val resultb2 = exclusionsAdd(eb, e2)
+        assert(result1b == eb)
+        assert(resultb1 == eb)
+        assert(result2b == eb)
+        assert(resultb2 == eb)
+      }
+    }
+
+    'intersect{
+      'basicZero{
+        val result1l = exclusionsIntersect(e1, Set.empty)
+        val result1r = exclusionsIntersect(Set.empty, e1)
+        val result2l = exclusionsIntersect(e2, Set.empty)
+        val result2r = exclusionsIntersect(Set.empty, e2)
+        assert(result1l == Set.empty)
+        assert(result1r == Set.empty)
+        assert(result2l == Set.empty)
+        assert(result2r == Set.empty)
+      }
+      'basic{
+        val expected = e1 ++ e2
+        val result12 = exclusionsIntersect(e1, e2)
+        val result21 = exclusionsIntersect(e2, e1)
+        assert(result12 == Set.empty)
+        assert(result21 == Set.empty)
+      }
+
+      'nameBlob{
+        val result1b = exclusionsIntersect(e1, enb)
+        val resultb1 = exclusionsIntersect(enb, e1)
+        val result2b = exclusionsIntersect(e2, enb)
+        val resultb2 = exclusionsIntersect(enb, e2)
+        assert(result1b == e1)
+        assert(resultb1 == e1)
+        assert(result2b == Set.empty)
+        assert(resultb2 == Set.empty)
+      }
+
+      'orgBlob{
+        val result1b = exclusionsIntersect(e1, eob)
+        val resultb1 = exclusionsIntersect(eob, e1)
+        val result2b = exclusionsIntersect(e2, eob)
+        val resultb2 = exclusionsIntersect(eob, e2)
+        assert(result1b == e1)
+        assert(resultb1 == e1)
+        assert(result2b == Set.empty)
+        assert(resultb2 == Set.empty)
+      }
+
+      'blob{
+        val result1b = exclusionsIntersect(e1, eb)
+        val resultb1 = exclusionsIntersect(eb, e1)
+        val result2b = exclusionsIntersect(e2, eb)
+        val resultb2 = exclusionsIntersect(eb, e2)
+        assert(result1b == e1)
+        assert(resultb1 == e1)
+        assert(result2b == e2)
+        assert(resultb2 == e2)
+      }
+    }
+  }
+
+}
diff --git a/core/src/test/scala/coursier/test/PomParsingTests.scala b/core/src/test/scala/coursier/test/PomParsingTests.scala
new file mode 100644
index 000000000..568ae6be8
--- /dev/null
+++ b/core/src/test/scala/coursier/test/PomParsingTests.scala
@@ -0,0 +1,143 @@
+package coursier
+package test
+
+import utest._
+import scalaz._
+
+import coursier.core.Xml
+import coursier.Profile.Activation
+import coursier.core.compatibility._
+
+object PomParsingTests extends TestSuite {
+
+  val tests = TestSuite {
+    'readClassifier{
+      val depNode ="""
+        <dependency>
+          <groupId>comp</groupId>
+          <artifactId>lib</artifactId>
+          <version>2.1</version>
+          <classifier>extra</classifier>
+        </dependency>
+                   """
+
+      val expected = \/-(Dependency(Module("comp", "lib", "2.1"), classifier = "extra"))
+
+      val result = Xml.dependency(xmlParse(depNode).right.get)
+
+      assert(result == expected)
+    }
+    'readProfileWithNoActivation{
+      val profileNode ="""
+        <profile>
+          <id>profile1</id>
+        </profile>
+                       """
+
+      val expected = \/-(Profile("profile1", None, Activation(Nil), Nil, Nil, Map.empty))
+
+      val result = Xml.profile(xmlParse(profileNode).right.get)
+
+      assert(result == expected)
+    }
+    'readProfileActivatedByDefault{
+      val profileNode ="""
+        <profile>
+          <id>profile1</id>
+          <activation>
+            <activeByDefault>true</activeByDefault>
+          </activation>
+        </profile>
+                       """
+
+      val expected = \/-(Profile("profile1", Some(true), Activation(Nil), Nil, Nil, Map.empty))
+
+      val result = Xml.profile(xmlParse(profileNode).right.get)
+
+      assert(result == expected)
+    }
+    'readProfileDependencies{
+      val profileNode ="""
+        <profile>
+          <id>profile1</id>
+          <dependencies>
+            <dependency>
+              <groupId>comp</groupId>
+              <artifactId>lib</artifactId>
+              <version>0.2</version>
+            </dependency>
+          </dependencies>
+        </profile>
+                       """
+
+      val expected = \/-(Profile(
+        "profile1",
+        None,
+        Activation(Nil),
+        Seq(
+          Dependency(Module("comp", "lib", "0.2"))),
+        Nil,
+        Map.empty
+      ))
+
+      val result = Xml.profile(xmlParse(profileNode).right.get)
+
+      assert(result == expected)
+    }
+    'readProfileDependenciesMgmt{
+      val profileNode ="""
+        <profile>
+          <id>profile1</id>
+          <dependencyManagement>
+            <dependencies>
+              <dependency>
+                <groupId>comp</groupId>
+                <artifactId>lib</artifactId>
+                <version>0.2</version>
+                <scope>test</scope>
+              </dependency>
+            </dependencies>
+          </dependencyManagement>
+        </profile>
+                       """
+
+      val expected = \/-(Profile(
+        "profile1",
+        None,
+        Activation(Nil),
+        Nil,
+        Seq(
+          Dependency(Module("comp", "lib", "0.2"), scope = Scope.Test)),
+        Map.empty
+      ))
+
+      val result = Xml.profile(xmlParse(profileNode).right.get)
+
+      assert(result == expected)
+    }
+    'readProfileProperties{
+      val profileNode ="""
+        <profile>
+          <id>profile1</id>
+          <properties>
+            <first.prop>value1</first.prop>
+          </properties>
+        </profile>
+                       """
+
+      val expected = \/-(Profile(
+        "profile1",
+        None,
+        Activation(Nil),
+        Nil,
+        Nil,
+        Map("first.prop" -> "value1")
+      ))
+
+      val result = Xml.profile(xmlParse(profileNode).right.get)
+
+      assert(result == expected)
+    }
+  }
+
+}
diff --git a/core/src/test/scala/coursier/test/ResolverTests.scala b/core/src/test/scala/coursier/test/ResolverTests.scala
new file mode 100644
index 000000000..9b6baf37c
--- /dev/null
+++ b/core/src/test/scala/coursier/test/ResolverTests.scala
@@ -0,0 +1,464 @@
+package coursier
+package test
+
+import coursier.core.Resolver
+import utest._
+import scala.async.Async.{async, await}
+
+import coursier.test.compatibility._
+
+object ResolverTests extends TestSuite {
+
+  implicit class ProjectOps(val p: Project) extends AnyVal {
+    def kv: (Module, (Repository, Project)) = p.module -> (testRepository, p)
+  }
+
+  val projects = Seq(
+    Project(Module("acme", "config", "1.3.0")),
+  
+    Project(Module("acme", "play", "2.4.0"), Seq(
+      Dependency(Module("acme", "play-json", "2.4.0")))),
+  
+    Project(Module("acme", "play-json", "2.4.0")),
+  
+    Project(Module("acme", "play", "2.4.1"),
+      Seq(
+        Dependency(Module("acme", "play-json", "${playJsonVersion}")),
+        Dependency(Module("${project.groupId}", "${configName}", "1.3.0"))),
+      properties = Map(
+        "playJsonVersion" -> "2.4.0",
+        "configName" -> "config")),
+  
+    Project(Module("acme", "play-extra-no-config", "2.4.1"),
+      Seq(
+        Dependency(Module("acme", "play", "2.4.1"),
+          exclusions = Set(("acme", "config"))))),
+
+    Project(Module("acme", "play-extra-no-config-no", "2.4.1"),
+      Seq(
+        Dependency(Module("acme", "play", "2.4.1"),
+          exclusions = Set(("*", "config"))))),
+
+    Project(Module("hudsucker", "mail", "10.0"),
+      Seq(
+        Dependency(Module("${project.groupId}", "test-util", "${project.version}"),
+          scope = Scope.Test))),
+
+    Project(Module("hudsucker", "test-util", "10.0")),
+
+    Project(Module("se.ikea", "parent", "18.0"),
+      dependencyManagement = Seq(
+        Dependency(Module("acme", "play", "2.4.0"),
+          exclusions = Set(("acme", "play-json"))))),
+
+    Project(Module("se.ikea", "billy", "18.0"),
+      Seq(
+        Dependency(Module("acme", "play", ""))
+      ),
+      parent = Some(Module("se.ikea", "parent", "18.0"))),
+
+    Project(Module("org.gnome", "parent", "7.0"),
+      Seq(
+        Dependency(Module("org.gnu", "glib", "13.4")))),
+
+    Project(Module("org.gnome", "panel-legacy", "7.0"),
+      Seq(
+        Dependency(Module("org.gnome", "desktop", "${project.version}"))),
+      parent = Some(Module("org.gnome", "parent", "7.0"))),
+
+    Project(Module("gov.nsa", "secure-pgp", "10.0"),
+      Seq(
+        Dependency(Module("gov.nsa", "crypto", "536.89")))),
+
+    Project(Module("com.mailapp", "mail-client", "2.1"),
+      Seq(
+        Dependency(Module("gov.nsa", "secure-pgp", "10.0"),
+          exclusions = Set(("*", "${crypto.name}")))),
+      properties = Map("crypto.name" -> "crypto", "dummy" -> "2")),
+
+    Project(Module("com.thoughtworks.paranamer", "paranamer-parent", "2.6"),
+      Seq(
+        Dependency(Module("junit", "junit", ""))),
+      dependencyManagement = Seq(
+        Dependency(Module("junit", "junit", "4.11"), scope = Scope.Test))),
+
+    Project(Module("com.thoughtworks.paranamer", "paranamer", "2.6"),
+      parent = Some(Module("com.thoughtworks.paranamer", "paranamer-parent", "2.6"))),
+
+    Project(Module("com.github.dummy", "libb", "0.3.3"),
+      profiles = Seq(
+        Profile("default", activeByDefault = Some(true), dependencies = Seq(
+          Dependency(Module("org.escalier", "librairie-standard", "2.11.6"))
+        ))
+      )),
+
+    Project(Module("com.github.dummy", "libb", "0.4.2"),
+      Seq(
+        Dependency(Module("org.scalaverification", "scala-verification", "1.12.4"))
+      ),
+      profiles = Seq(
+        Profile("default", activeByDefault = Some(true), dependencies = Seq(
+          Dependency(Module("org.escalier", "librairie-standard", "2.11.6")),
+          Dependency(Module("org.scalaverification", "scala-verification", "1.12.4"), scope = Scope.Test)
+        ))
+      )),
+
+    Project(Module("com.github.dummy", "libb", "0.5.3"),
+      properties = Map("special" -> "true"),
+      profiles = Seq(
+        Profile("default", activation = Profile.Activation(properties = Seq("special" -> None)), dependencies = Seq(
+          Dependency(Module("org.escalier", "librairie-standard", "2.11.6"))
+        ))
+      )),
+
+    Project(Module("com.github.dummy", "libb", "0.5.4"),
+      properties = Map("special" -> "true"),
+      profiles = Seq(
+        Profile("default", activation = Profile.Activation(properties = Seq("special" -> Some("true"))), dependencies = Seq(
+          Dependency(Module("org.escalier", "librairie-standard", "2.11.6"))
+        ))
+      )),
+
+    Project(Module("com.github.dummy", "libb", "0.5.5"),
+      properties = Map("special" -> "true"),
+      profiles = Seq(
+        Profile("default", activation = Profile.Activation(properties = Seq("special" -> Some("!false"))), dependencies = Seq(
+          Dependency(Module("org.escalier", "librairie-standard", "2.11.6"))
+        ))
+      )),
+
+    Project(Module("com.github.dummy", "libb-parent", "0.5.6"),
+      properties = Map("special" -> "true")),
+
+    Project(Module("com.github.dummy", "libb", "0.5.6"),
+      parent = Some(Module("com.github.dummy", "libb-parent", "0.5.6")),
+      properties = Map("special" -> "true"),
+      profiles = Seq(
+        Profile("default", activation = Profile.Activation(properties = Seq("special" -> Some("!false"))), dependencies = Seq(
+          Dependency(Module("org.escalier", "librairie-standard", "2.11.6"))
+        ))
+      ))
+  )
+
+  val projectsMap = projects.map(p => p.module -> p).toMap
+  val testRepository: Repository = new TestRepository(projectsMap)
+
+  val repositories = Seq[Repository](
+    testRepository
+  )
+
+  val tests = TestSuite {
+    'empty{
+      async{
+        val res = await(resolve(
+          Set.empty,
+          fetchFrom(repositories)
+        ).runF
+        )
+
+        assert(res == Resolution.empty)
+      }
+    }
+    'notFound{
+      async {
+        val dep = Dependency(Module("acme", "playy", "2.4.0"))
+        val res = await(resolve(
+          Set(dep),
+          fetchFrom(repositories)
+        ).runF)
+
+        val expected = Resolution(
+          rootDependencies = Set(dep.withCompileScope),
+          dependencies = Set(dep.withCompileScope),
+          errors = Map(dep.module -> Seq("Not found"))
+        )
+
+        assert(res == expected)
+      }
+    }
+    'single{
+      async {
+      val dep = Dependency(Module("acme", "config", "1.3.0"))
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories)
+      ).runF)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope),
+        projectsCache = Map(dep.module -> (testRepository, projectsMap(dep.module)))
+      )
+
+      assert(res == expected)
+      }
+    }
+    'oneTransitiveDependency{
+      async {
+      val dep = Dependency(Module("acme", "play", "2.4.0"))
+      val trDep = Dependency(Module("acme", "play-json", "2.4.0"))
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories)
+      ).runF)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope, trDep.withCompileScope),
+        projectsCache = Map(
+          projectsMap(dep.module).kv,
+          projectsMap(trDep.module).kv
+        )
+      )
+
+      assert(res == expected)
+      }
+    }
+    'twoTransitiveDependencyWithProps{
+      async {
+      val dep = Dependency(Module("acme", "play", "2.4.1"))
+      val trDeps = Seq(
+        Dependency(Module("acme", "play-json", "2.4.0")),
+        Dependency(Module("acme", "config", "1.3.0"))
+      )
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories)
+      ).runF)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope) ++ trDeps.map(_.withCompileScope),
+        projectsCache = Map(
+          projectsMap(dep.module).kv
+        ) ++ trDeps.map(trDep => projectsMap(trDep.module).kv)
+      )
+
+      assert(res == expected)
+      }
+    }
+    'exclude{
+      async {
+      val dep = Dependency(Module("acme", "play-extra-no-config", "2.4.1"))
+      val trDeps = Seq(
+        Dependency(Module("acme", "play", "2.4.1"),
+          exclusions = Set(("acme", "config"))),
+        Dependency(Module("acme", "play-json", "2.4.0"),
+          exclusions = Set(("acme", "config")))
+      )
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories)
+      ).runF)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope) ++ trDeps.map(_.withCompileScope),
+        projectsCache = Map(
+          projectsMap(dep.module).kv
+        ) ++ trDeps.map(trDep => projectsMap(trDep.module).kv)
+      )
+
+      assert(res == expected)
+      }
+    }
+    'excludeOrgWildcard{
+      async {
+      val dep = Dependency(Module("acme", "play-extra-no-config-no", "2.4.1"))
+      val trDeps = Seq(
+        Dependency(Module("acme", "play", "2.4.1"),
+          exclusions = Set(("*", "config"))),
+        Dependency(Module("acme", "play-json", "2.4.0"),
+          exclusions = Set(("*", "config")))
+      )
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories)
+      ).runF)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope) ++ trDeps.map(_.withCompileScope),
+        projectsCache = Map(
+          projectsMap(dep.module).kv
+        ) ++ trDeps.map(trDep => projectsMap(trDep.module).kv)
+      )
+
+      assert(res == expected)
+      }
+    }
+    'filter{
+      async {
+      val dep = Dependency(Module("hudsucker", "mail", "10.0"))
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories),
+        filter = Some(_.scope == Scope.Compile)
+      ).runF).copy(filter = None)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope),
+        projectsCache = Map(
+          projectsMap(dep.module).kv
+        )
+      )
+
+      assert(res == expected)
+      }
+    }
+    'parentDepMgmt{
+      async {
+      val dep = Dependency(Module("se.ikea", "billy", "18.0"))
+      val trDeps = Seq(
+        Dependency(Module("acme", "play", "2.4.0"),
+          exclusions = Set(("acme", "play-json")))
+      )
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories),
+        filter = Some(_.scope == Scope.Compile)
+      ).runF).copy(filter = None, projectsCache = Map.empty)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope) ++ trDeps.map(_.withCompileScope)
+      )
+
+      assert(res == expected)
+      }
+    }
+    'parentDependencies{
+      async {
+      val dep = Dependency(Module("org.gnome", "panel-legacy", "7.0"))
+      val trDeps = Seq(
+        Dependency(Module("org.gnu", "glib", "13.4")),
+        Dependency(Module("org.gnome", "desktop", "7.0")))
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories),
+        filter = Some(_.scope == Scope.Compile)
+      ).runF).copy(filter = None, projectsCache = Map.empty, errors = Map.empty)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope) ++ trDeps.map(_.withCompileScope)
+      )
+
+      assert(res == expected)
+      }
+    }
+    'propertiesInExclusions{
+      async {
+      val dep = Dependency(Module("com.mailapp", "mail-client", "2.1"))
+      val trDeps = Seq(
+        Dependency(Module("gov.nsa", "secure-pgp", "10.0"), exclusions = Set(("*", "crypto"))))
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories),
+        filter = Some(_.scope == Scope.Compile)
+      ).runF).copy(filter = None, projectsCache = Map.empty, errors = Map.empty)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope) ++ trDeps.map(_.withCompileScope)
+      )
+
+      assert(res == expected)
+      }
+    }
+    'depMgmtInParentDeps{
+      async {
+      val dep = Dependency(Module("com.thoughtworks.paranamer", "paranamer", "2.6"))
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories),
+        filter = Some(_.scope == Scope.Compile)
+      ).runF).copy(filter = None, projectsCache = Map.empty, errors = Map.empty)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope)
+      )
+
+      assert(res == expected)
+      }
+    }
+    'depsFromDefaultProfile{
+      async {
+      val dep = Dependency(Module("com.github.dummy", "libb", "0.3.3"))
+      val trDeps = Seq(
+        Dependency(Module("org.escalier", "librairie-standard", "2.11.6")))
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories),
+        filter = Some(_.scope == Scope.Compile)
+      ).runF).copy(filter = None, projectsCache = Map.empty, errors = Map.empty)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope) ++ trDeps.map(_.withCompileScope)
+      )
+
+      assert(res == expected)
+      }
+    }
+    'depsFromPropertyActivatedProfile{
+      val f =
+      for (version <- Seq("0.5.3", "0.5.4", "0.5.5", "0.5.6")) yield {
+        async {
+        val dep = Dependency(Module("com.github.dummy", "libb", version))
+        val trDeps = Seq(
+          Dependency(Module("org.escalier", "librairie-standard", "2.11.6")))
+        val res = await(resolve(
+          Set(dep),
+          fetchFrom(repositories),
+          filter = Some(_.scope == Scope.Compile)
+        ).runF).copy(filter = None, projectsCache = Map.empty, errors = Map.empty)
+
+        val expected = Resolution(
+          rootDependencies = Set(dep.withCompileScope),
+          dependencies = Set(dep.withCompileScope) ++ trDeps.map(_.withCompileScope)
+        )
+
+        assert(res == expected)
+      }
+      }
+
+      scala.concurrent.Future.sequence(f)
+    }
+    'depsScopeOverrideFromProfile{
+      async {
+      // Like com.google.inject:guice:3.0 with org.sonatype.sisu.inject:cglib
+      val dep = Dependency(Module("com.github.dummy", "libb", "0.4.2"))
+      val trDeps = Seq(
+        Dependency(Module("org.escalier", "librairie-standard", "2.11.6")))
+      val res = await(resolve(
+        Set(dep),
+        fetchFrom(repositories),
+        filter = Some(_.scope == Scope.Compile)
+      ).runF).copy(filter = None, projectsCache = Map.empty, errors = Map.empty)
+
+      val expected = Resolution(
+        rootDependencies = Set(dep.withCompileScope),
+        dependencies = Set(dep.withCompileScope) ++ trDeps.map(_.withCompileScope)
+      )
+
+      assert(res == expected)
+      }
+    }
+
+    'parts{
+      'propertySubstitution{
+        val res =
+          Resolver.withProperties(
+            Seq(Dependency(Module("a-company", "a-name", "${a.property}"))),
+            Map("a.property" -> "a-version"))
+        val expected = Seq(Dependency(Module("a-company", "a-name", "a-version")))
+
+        assert(res == expected)
+      }
+    }
+  }
+
+}
diff --git a/core/src/test/scala/coursier/test/TestRepository.scala b/core/src/test/scala/coursier/test/TestRepository.scala
new file mode 100644
index 000000000..b79e638ac
--- /dev/null
+++ b/core/src/test/scala/coursier/test/TestRepository.scala
@@ -0,0 +1,19 @@
+package coursier
+package test
+
+import coursier.core.{Versions, CachePolicy}
+
+import scalaz.{-\/, \/, EitherT}
+import scalaz.concurrent.Task
+import scalaz.Scalaz._
+
+class TestRepository(projects: Map[Module, Project]) extends Repository {
+  def find(module: Module, cachePolicy: CachePolicy) =
+    EitherT(Task.now(
+      projects.get(module).toRightDisjunction("Not found")
+    ))
+  def versions(organization: String, name: String, cachePolicy: CachePolicy) =
+    EitherT(Task.now[String \/ Versions](
+      -\/("Not supported")
+    ))
+}
diff --git a/core/src/test/scala/coursier/test/VersionConstraintTests.scala b/core/src/test/scala/coursier/test/VersionConstraintTests.scala
new file mode 100644
index 000000000..2227e7537
--- /dev/null
+++ b/core/src/test/scala/coursier/test/VersionConstraintTests.scala
@@ -0,0 +1,56 @@
+package coursier
+package test
+
+import coursier.core._
+import utest._
+
+object VersionConstraintTests extends TestSuite {
+
+  val tests = TestSuite {
+    'parse{
+      'empty{
+        val c0 = Parse.versionConstraint("")
+        assert(c0 == Some(VersionConstraint.None))
+      }
+      'basicVersion{
+        val c0 = Parse.versionConstraint("1.2")
+        assert(c0 == Some(VersionConstraint.Preferred(Version("1.2"))))
+      }
+      'basicVersionInterval{
+        val c0 = Parse.versionConstraint("(,1.2]")
+        assert(c0 == Some(VersionConstraint.Interval(VersionInterval(None, Some(Version("1.2")), false, true))))
+      }
+    }
+
+    'repr{
+      'empty{
+        val s0 = VersionConstraint.None.repr
+        assert(s0 == "")
+      }
+      'preferred{
+        val s0 = VersionConstraint.Preferred(Version("2.1")).repr
+        assert(s0 == "2.1")
+      }
+      'interval{
+        val s0 = VersionConstraint.Interval(VersionInterval(None, Some(Version("2.1")), false, true)).repr
+        assert(s0 == "(,2.1]")
+      }
+    }
+
+    'interval{
+      'empty{
+        val s0 = VersionConstraint.None.interval
+        assert(s0 == VersionInterval.zero)
+      }
+      'preferred{
+        val s0 = VersionConstraint.Preferred(Version("2.1")).interval
+        assert(s0 == VersionInterval(Some(Version("2.1")), None, true, false))
+      }
+      'interval{
+        val s0 = VersionConstraint.Interval(VersionInterval(None, Some(Version("2.1")), false, true)).interval
+        assert(s0 == VersionInterval(None, Some(Version("2.1")), false, true))
+      }
+    }
+  }
+
+}
diff --git a/core/src/test/scala/coursier/test/VersionIntervalTests.scala b/core/src/test/scala/coursier/test/VersionIntervalTests.scala
new file mode 100644
index 000000000..4a7c06288
--- /dev/null
+++ b/core/src/test/scala/coursier/test/VersionIntervalTests.scala
@@ -0,0 +1,318 @@
+package coursier
+package test
+
+import coursier.core._
+import utest._
+
+object VersionIntervalTests extends TestSuite {
+
+  val tests = TestSuite{
+    'invalid{
+      'basic{
+        assert(VersionInterval.zero.isValid)
+
+        val itv1 = VersionInterval(None, None, true, true)
+        val itv2 = VersionInterval(None, None, false, true)
+        val itv3 = VersionInterval(None, None, true, false)
+
+        assert(!itv1.isValid)
+        assert(!itv2.isValid)
+        assert(!itv3.isValid)
+      }
+      'halfBounded{
+        val itv1 = VersionInterval(Some(Version("1.2")), None, true, true)
+        val itv2 = VersionInterval(Some(Version("1.2")), None, false, true)
+        val itv3 = VersionInterval(None, Some(Version("1.2")), true, true)
+        val itv4 = VersionInterval(None, Some(Version("1.2")), true, false)
+
+        assert(!itv1.isValid)
+        assert(!itv2.isValid)
+        assert(!itv3.isValid)
+        assert(!itv4.isValid)
+      }
+      'order{
+        val itv1 = VersionInterval(Some(Version("2")), Some(Version("1")), true, true)
+        val itv2 = VersionInterval(Some(Version("2")), Some(Version("1")), false, true)
+        val itv3 = VersionInterval(Some(Version("2")), Some(Version("1")), true, false)
+        val itv4 = VersionInterval(Some(Version("2")), Some(Version("1")), false, false)
+
+        assert(!itv1.isValid)
+        assert(!itv2.isValid)
+        assert(!itv3.isValid)
+        assert(!itv4.isValid)
+      }
+      'bound{
+        val itv1 = VersionInterval(Some(Version("2")), Some(Version("2")), false, true)
+        val itv2 = VersionInterval(Some(Version("2")), Some(Version("2")), true, false)
+        val itv3 = VersionInterval(Some(Version("2")), Some(Version("2")), false, false)
+
+        assert(!itv1.isValid)
+        assert(!itv2.isValid)
+        assert(!itv3.isValid)
+
+        val itv4 = VersionInterval(Some(Version("2")), Some(Version("2")), true, true)
+        assert(itv4.isValid)
+      }
+    }
+
+    'merge{
+      'basic{
+        val itv0m = VersionInterval.zero.merge(VersionInterval.zero)
+        assert(itv0m == Some(VersionInterval.zero))
+
+        val itv1 = VersionInterval(Some(Version("1")), Some(Version("2")), false, true)
+        val itv1m = itv1.merge(VersionInterval.zero)
+        val itv1m0 = VersionInterval.zero.merge(itv1)
+        assert(itv1m == Some(itv1))
+        assert(itv1m0 == Some(itv1))
+      }
+      'noIntersec{
+        val itv1 = VersionInterval(Some(Version("1")), Some(Version("2")), true, false)
+        val itv2 = VersionInterval(Some(Version("3")), Some(Version("5")), false, true)
+        val itvm = itv1 merge itv2
+        val itvm0 = itv2 merge itv1
+        assert(itvm == None)
+        assert(itvm0 == None)
+      }
+      'noIntersecSameFrontierOpenClose{
+        val itv1 = VersionInterval(Some(Version("1")), Some(Version("2")), true, false)
+        val itv2 = VersionInterval(Some(Version("2")), Some(Version("4")), true, true)
+        val itvm = itv1 merge itv2
+        val itvm0 = itv2 merge itv1
+        assert(itvm == None)
+        assert(itvm0 == None)
+      }
+      'noIntersecSameFrontierCloseOpen{
+        val itv1 = VersionInterval(Some(Version("1")), Some(Version("2")), true, true)
+        val itv2 = VersionInterval(Some(Version("2")), Some(Version("4")), false, true)
+        val itvm = itv1 merge itv2
+        val itvm0 = itv2 merge itv1
+        assert(itvm == None)
+        assert(itvm0 == None)
+      }
+      'noIntersecSameFrontierOpenOpen{
+        val itv1 = VersionInterval(Some(Version("1")), Some(Version("2")), true, false)
+        val itv2 = VersionInterval(Some(Version("2")), Some(Version("4")), false, true)
+        val itvm = itv1 merge itv2
+        val itvm0 = itv2 merge itv1
+        assert(itvm == None)
+        assert(itvm0 == None)
+      }
+      'intersecSameFrontierCloseClose{
+        val itv1 = VersionInterval(Some(Version("1")), Some(Version("2")), true, true)
+        val itv2 = VersionInterval(Some(Version("2")), Some(Version("4")), true, true)
+        val itvm = itv1 merge itv2
+        val itvm0 = itv2 merge itv1
+        val expected = VersionInterval(Some(Version("2")), Some(Version("2")), true, true)
+        assert(itvm == Some(expected))
+        assert(itvm0 == Some(expected))
+      }
+      'intersec{
+        val bools = Seq(true, false)
+        for (l1 <- bools; l2 <- bools; r1 <- bools; r2 <- bools) {
+          val itv1 = VersionInterval(Some(Version("1")), Some(Version("3")), l1, r1)
+          val itv2 = VersionInterval(Some(Version("2")), Some(Version("4")), l2, r2)
+          val itvm = itv1 merge itv2
+          val itvm0 = itv2 merge itv1
+          val expected = VersionInterval(Some(Version("2")), Some(Version("3")), l2, r1)
+          assert(itvm == Some(expected))
+          assert(itvm0 == Some(expected))
+        }
+      }
+    }
+
+    'parse{
+      'malformed{
+        val s1 = "[1.1]"
+        val itv1 = Parse.versionInterval(s1)
+        assert(itv1 == None)
+
+        val s2 = "(1.1)"
+        val itv2 = Parse.versionInterval(s2)
+        assert(itv2 == None)
+
+        val s3 = "()"
+        val itv3 = Parse.versionInterval(s3)
+        assert(itv3 == None)
+
+        val s4 = "[1.1,1.3"
+        val itv4 = Parse.versionInterval(s4)
+        assert(itv4 == None)
+
+        val s5 = "1.1,1.3)"
+        val itv5 = Parse.versionInterval(s5)
+        assert(itv5 == None)
+      }
+      'basic {
+        val s1 = "[1.1,1.3]"
+        val itv1 = Parse.versionInterval(s1)
+        assert(itv1 == Some(VersionInterval(Some(Version("1.1")), Some(Version("1.3")), true, true)))
+
+        val s2 = "(1.1,1.3]"
+        val itv2 = Parse.versionInterval(s2)
+        assert(itv2 == Some(VersionInterval(Some(Version("1.1")), Some(Version("1.3")), false, true)))
+
+        val s3 = "[1.1,1.3)"
+        val itv3 = Parse.versionInterval(s3)
+        assert(itv3 == Some(VersionInterval(Some(Version("1.1")), Some(Version("1.3")), true, false)))
+
+        val s4 = "(1.1,1.3)"
+        val itv4 = Parse.versionInterval(s4)
+        assert(itv4 == Some(VersionInterval(Some(Version("1.1")), Some(Version("1.3")), false, false)))
+      }
+      'leftEmptyVersions {
+        val s1 = "[,1.3]"
+        val itv1 = Parse.versionInterval(s1)
+        assert(itv1 == Some(VersionInterval(None, Some(Version("1.3")), true, true)))
+        assert(!itv1.get.isValid)
+
+        val s2 = "(,1.3]"
+        val itv2 = Parse.versionInterval(s2)
+        assert(itv2 == Some(VersionInterval(None, Some(Version("1.3")), false, true)))
+        assert(itv2.get.isValid)
+
+        val s3 = "[,1.3)"
+        val itv3 = Parse.versionInterval(s3)
+        assert(itv3 == Some(VersionInterval(None, Some(Version("1.3")), true, false)))
+        assert(!itv3.get.isValid)
+
+        val s4 = "(,1.3)"
+        val itv4 = Parse.versionInterval(s4)
+        assert(itv4 == Some(VersionInterval(None, Some(Version("1.3")), false, false)))
+        assert(itv4.get.isValid)
+      }
+      'rightEmptyVersions {
+        val s1 = "[1.3,]"
+        val itv1 = Parse.versionInterval(s1)
+        assert(itv1 == Some(VersionInterval(Some(Version("1.3")), None, true, true)))
+        assert(!itv1.get.isValid)
+
+        val s2 = "(1.3,]"
+        val itv2 = Parse.versionInterval(s2)
+        assert(itv2 == Some(VersionInterval(Some(Version("1.3")), None, false, true)))
+        assert(!itv2.get.isValid)
+
+        val s3 = "[1.3,)"
+        val itv3 = Parse.versionInterval(s3)
+        assert(itv3 == Some(VersionInterval(Some(Version("1.3")), None, true, false)))
+        assert(itv3.get.isValid)
+
+        val s4 = "(1.3,)"
+        val itv4 = Parse.versionInterval(s4)
+        assert(itv4 == Some(VersionInterval(Some(Version("1.3")), None, false, false)))
+        assert(itv4.get.isValid)
+      }
+      'bothEmptyVersions {
+        val s1 = "[,]"
+        val itv1 = Parse.versionInterval(s1)
+        assert(itv1 == Some(VersionInterval(None, None, true, true)))
+        assert(!itv1.get.isValid)
+
+        val s2 = "(,]"
+        val itv2 = Parse.versionInterval(s2)
+        assert(itv2 == Some(VersionInterval(None, None, false, true)))
+        assert(!itv2.get.isValid)
+
+        val s3 = "[,)"
+        val itv3 = Parse.versionInterval(s3)
+        assert(itv3 == Some(VersionInterval(None, None, true, false)))
+        assert(!itv3.get.isValid)
+
+        val s4 = "(,]"
+        val itv4 = Parse.versionInterval(s4)
+        assert(itv4 == Some(VersionInterval(None, None, false, true)))
+        assert(!itv4.get.isValid)
+      }
+    }
+
+    'repr{
+      'basic {
+        val s1 = "[1.1,1.3]"
+        val repr1 = Parse.versionInterval(s1).map(_.repr)
+        assert(repr1 == Some(s1))
+
+        val s2 = "(1.1,1.3]"
+        val repr2 = Parse.versionInterval(s2).map(_.repr)
+        assert(repr2 == Some(s2))
+
+        val s3 = "[1.1,1.3)"
+        val repr3 = Parse.versionInterval(s3).map(_.repr)
+        assert(repr3 == Some(s3))
+
+        val s4 = "(1.1,1.3)"
+        val repr4 = Parse.versionInterval(s4).map(_.repr)
+        assert(repr4 == Some(s4))
+      }
+      'leftEmptyVersions {
+        val s1 = "[,1.3]"
+        val repr1 = Parse.versionInterval(s1).map(_.repr)
+        assert(repr1 == Some(s1))
+
+        val s2 = "(,1.3]"
+        val repr2 = Parse.versionInterval(s2).map(_.repr)
+        assert(repr2 == Some(s2))
+
+        val s3 = "[,1.3)"
+        val repr3 = Parse.versionInterval(s3).map(_.repr)
+        assert(repr3 == Some(s3))
+
+        val s4 = "(,1.3)"
+        val repr4 = Parse.versionInterval(s4).map(_.repr)
+        assert(repr4 == Some(s4))
+      }
+      'rightEmptyVersions {
+        val s1 = "[1.3,]"
+        val repr1 = Parse.versionInterval(s1).map(_.repr)
+        assert(repr1 == Some(s1))
+
+        val s2 = "(1.3,]"
+        val repr2 = Parse.versionInterval(s2).map(_.repr)
+        assert(repr2 == Some(s2))
+
+        val s3 = "[1.3,)"
+        val repr3 = Parse.versionInterval(s3).map(_.repr)
+        assert(repr3 == Some(s3))
+
+        val s4 = "(1.3,)"
+        val repr4 = Parse.versionInterval(s4).map(_.repr)
+        assert(repr4 == Some(s4))
+      }
+      'bothEmptyVersions {
+        val s1 = "[,]"
+        val repr1 = Parse.versionInterval(s1).map(_.repr)
+        assert(repr1 == Some(s1))
+
+        val s2 = "(,]"
+        val repr2 = Parse.versionInterval(s2).map(_.repr)
+        assert(repr2 == Some(s2))
+
+        val s3 = "[,)"
+        val repr3 = Parse.versionInterval(s3).map(_.repr)
+        assert(repr3 == Some(s3))
+
+        val s4 = "(,]"
+        val repr4 = Parse.versionInterval(s4).map(_.repr)
+        assert(repr4 == Some(s4))
+      }
+    }
+
+    'constraint{
+      'none{
+        val s1 = "(,)"
+        val c1 = Parse.versionInterval(s1).map(_.constraint)
+        assert(c1 == Some(VersionConstraint.None))
+      }
+      'preferred{
+        val s1 = "[1.3,)"
+        val c1 = Parse.versionInterval(s1).map(_.constraint)
+        assert(c1 == Some(VersionConstraint.Preferred(Parse.version("1.3").get)))
+      }
+      'interval{
+        val s1 = "[1.3,2.4)"
+        val c1 = Parse.versionInterval(s1).map(_.constraint)
+        assert(c1 == Some(VersionConstraint.Interval(VersionInterval(Parse.version("1.3"), Parse.version("2.4"), true, false))))
+      }
+    }
+  }
+
+}
diff --git a/core/src/test/scala/coursier/test/package.scala b/core/src/test/scala/coursier/test/package.scala
new file mode 100644
index 000000000..863eb2519
--- /dev/null
+++ b/core/src/test/scala/coursier/test/package.scala
@@ -0,0 +1,9 @@
+package coursier
+
+package object test {
+
+  implicit class DependencyOps(val underlying: Dependency) extends AnyVal {
+    def withCompileScope: Dependency = underlying.copy(scope = Scope.Compile)
+  }
+
+}
diff --git a/project/Coursier.scala b/project/Coursier.scala
new file mode 100644
index 000000000..d5923610b
--- /dev/null
+++ b/project/Coursier.scala
@@ -0,0 +1,121 @@
+import org.scalajs.sbtplugin.ScalaJSPlugin
+import org.scalajs.sbtplugin.ScalaJSPlugin.autoImport._
+
+import sbt._, Keys._
+
+import sbtrelease.ReleasePlugin.releaseSettings
+import sbtrelease.ReleasePlugin.ReleaseKeys.{ publishArtifactsAction, versionBump }
+import sbtrelease.Version.Bump
+import com.typesafe.sbt.pgp.PgpKeys
+
+object CoursierBuild extends Build {
+
+  lazy val publishingSettings = Seq[Setting[_]](
+    publishMavenStyle := true,
+    publishTo := {
+      val nexus = "https://oss.sonatype.org/"
+      if (isSnapshot.value)
+        Some("snapshots" at nexus + "content/repositories/snapshots")
+      else
+        Some("releases"  at nexus + "service/local/staging/deploy/maven2")
+    },
+    pomExtra := {
+      <url>https://github.com/alexarchambault/coursier</url>
+      <licenses>
+        <license>
+          <name>Apache 2.0</name>
+          <url>http://opensource.org/licenses/Apache-2.0</url>
+        </license>
+      </licenses>
+      <scm>
+        <connection>scm:git:github.com/alexarchambault/coursier.git</connection>
+        <developerConnection>scm:git:git@github.com:alexarchambault/coursier.git</developerConnection>
+        <url>github.com/alexarchambault/coursier.git</url>
+      </scm>
+      <developers>
+        <developer>
+          <id>alexarchambault</id>
+          <name>Alexandre Archambault</name>
+          <url>https://github.com/alexarchambault</url>
+        </developer>
+      </developers>
+    },
+    credentials += {
+      Seq("SONATYPE_USER", "SONATYPE_PASS").map(sys.env.get) match {
+        case Seq(Some(user), Some(pass)) =>
+          Credentials("Sonatype Nexus Repository Manager", "oss.sonatype.org", user, pass)
+        case _ =>
+          Credentials(Path.userHome / ".ivy2" / ".credentials")
+      }
+    },
+    versionBump := Bump.Bugfix,
+    publishArtifactsAction := PgpKeys.publishSigned.value
+  ) ++ releaseSettings
+
+  lazy val commonSettings = Seq[Setting[_]](
+    organization := "eu.frowning-lambda",
+    version := "0.1.0-SNAPSHOT",
+    scalaVersion := "2.11.6",
+    crossScalaVersions := Seq("2.10.5", "2.11.6"),
+    resolvers += "Scalaz Bintray Repo" at "http://dl.bintray.com/scalaz/releases"
+  ) ++ publishingSettings
+
+  private lazy val commonCoreSettings = Seq[Setting[_]](
+    name := "coursier",
+    libraryDependencies += "org.scala-lang.modules" %% "scala-async" % "0.9.1" % "provided",
+    unmanagedSourceDirectories in Compile += (baseDirectory in LocalRootProject).value / "core" / "src" / "main" / "scala",
+    unmanagedSourceDirectories in Test += (baseDirectory in LocalRootProject).value / "core" / "src" / "test" / "scala",
+    testFrameworks += new TestFramework("utest.runner.Framework")
+  )
+
+  lazy val coreJvm = Project(id = "core-jvm", base = file("core-jvm"))
+    .settings(commonSettings ++ commonCoreSettings: _*)
+    .settings(
+      libraryDependencies ++= Seq(
+        "org.http4s" %% "http4s-blazeclient" % "0.7.0",
+        "com.lihaoyi" %% "utest" % "0.3.0" % "test"
+      ) ++ {
+        if (scalaVersion.value.startsWith("2.10.")) Seq()
+        else Seq(
+          "org.scala-lang.modules" %% "scala-xml" % "1.0.3"
+        )
+      }
+    )
+
+  lazy val coreJs = Project(id = "core-js", base = file("core-js"))
+    .settings(commonSettings ++ commonCoreSettings: _*)
+    .settings(
+      libraryDependencies ++= Seq(
+        "org.scala-js" %%% "scalajs-dom" % "0.8.0",
+        "com.github.japgolly.fork.scalaz" %%% "scalaz-core" % (if (scalaVersion.value.startsWith("2.10.")) "7.1.1" else "7.1.2"),
+        "be.doeraene" %%% "scalajs-jquery" % "0.8.0",
+        "com.lihaoyi" %%% "utest" % "0.3.0" % "test"
+      ),
+      postLinkJSEnv := NodeJSEnv().value,
+      scalaJSStage in Global := FastOptStage
+    )
+    .enablePlugins(ScalaJSPlugin)
+
+  lazy val cli = Project(id = "cli", base = file("cli"))
+    .dependsOn(coreJvm)
+    .settings(commonSettings ++ xerial.sbt.Pack.packAutoSettings: _*)
+    .settings(
+      libraryDependencies ++= Seq(
+        "com.github.alexarchambault" %% "case-app" % "0.2.2",
+        "ch.qos.logback" % "logback-classic" % "1.1.3"
+      )
+    )
+
+  lazy val web = Project(id = "web", base = file("web"))
+    .dependsOn(coreJs)
+    .settings(commonSettings: _*)
+    .settings(
+      libraryDependencies ++= Seq(
+        "com.github.japgolly.scalajs-react" %%% "core" % "0.9.0"
+      ),
+      jsDependencies +=
+        "org.webjars" % "react" % "0.12.2" / "react-with-addons.js" commonJSName "React"
+    )
+    .enablePlugins(ScalaJSPlugin)
+
+}
diff --git a/project/build.properties b/project/build.properties
new file mode 100644
index 000000000..a6e117b61
--- /dev/null
+++ b/project/build.properties
@@ -0,0 +1 @@
+sbt.version=0.13.8
diff --git a/project/plugins.sbt b/project/plugins.sbt
new file mode 100644
index 000000000..556b5cc83
--- /dev/null
+++ b/project/plugins.sbt
@@ -0,0 +1,7 @@
+addSbtPlugin("org.xerial.sbt" % "sbt-pack" % "0.6.8")
+
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % "0.6.3")
+
+addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.0")
+
+addSbtPlugin("com.github.gseitz" % "sbt-release" % "0.8.5")
diff --git a/project/travis.sh b/project/travis.sh
new file mode 100755
index 000000000..7640244b3
--- /dev/null
+++ b/project/travis.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+set -ev
+
+TRAVIS_SCALA_VERSION="$1"
+shift
+TRAVIS_PULL_REQUEST="$1"
+shift
+TRAVIS_BRANCH="$1"
+shift
+
+
+function isPr() {
+  [ "$TRAVIS_PULL_REQUEST" = "false" ]
+}
+
+function isJdk7() {
+  [ "$JAVA_HOME" = "$(jdk_switcher home oraclejdk7)" ]
+}
+
+function isMaster() {
+  [ "$TRAVIS_BRANCH" = "master" ]
+}
+
+if echo "$TRAVIS_SCALA_VERSION" | grep -q "^2\.10"; then
+  if isPr && isJdk7 && isMaster; then
+    EXTRA_SBT_ARGS="core-jvm/publish core-js/publish cli/publish"
+  else
+    EXTRA_SBT_ARGS=""
+  fi
+
+  sbt ++${TRAVIS_SCALA_VERSION} core-jvm/test core-js/test cli/test $EXTRA_SBT_ARGS
+else
+  if isPr && isJdk7 && isMaster; then
+    EXTRA_SBT_ARGS="publish"
+  else
+    EXTRA_SBT_ARGS=""
+  fi
+
+  sbt ++${TRAVIS_SCALA_VERSION} test $EXTRA_SBT_ARGS
+fi
diff --git a/version.sbt b/version.sbt
new file mode 100644
index 000000000..57b0bcbcd
--- /dev/null
+++ b/version.sbt
@@ -0,0 +1 @@
+version in ThisBuild := "0.1.0-SNAPSHOT"
diff --git a/web/src/main/resources/css/bootstrap-treeview.css b/web/src/main/resources/css/bootstrap-treeview.css
new file mode 100644
index 000000000..23c6cf066
--- /dev/null
+++ b/web/src/main/resources/css/bootstrap-treeview.css
@@ -0,0 +1,37 @@
+/* =========================================================
+ * bootstrap-treeview.css v1.2.0
+ * =========================================================
+ * Copyright 2013 Jonathan Miles 
+ * Project URL : http://www.jondmiles.com/bootstrap-treeview
+ *	
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================= */
+
+.treeview .list-group-item {
+	cursor: pointer;
+}
+
+.treeview span.indent {
+	margin-left: 10px;
+	margin-right: 10px;
+}
+
+.treeview span.icon {
+	width: 12px;
+	margin-right: 5px;
+}
+
+.treeview .node-disabled {
+	color: silver;
+	cursor: not-allowed;
+}
\ No newline at end of file
diff --git a/web/src/main/resources/index-dev.html b/web/src/main/resources/index-dev.html
new file mode 100644
index 000000000..d44e23e63
--- /dev/null
+++ b/web/src/main/resources/index-dev.html
@@ -0,0 +1,143 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dependency resolution with Coursier</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+
+  <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
+  <link rel="stylesheet" href="css/bootstrap-treeview.css">
+
+  <style>
+      .icon-action {
+        cursor: pointer;
+      }
+
+      #resolveButton {
+        margin-top: 20px;
+        margin-bottom: 20px;
+      }
+
+      #results {
+        display: none;
+      }
+
+      .customButton {
+        margin: 5px;
+      }
+  </style>
+
+</head>
+<body style="margin: 0px">
+
+<div class="container theme-showcase" role="main">
+
+<nav class="navbar navbar-default">
+  <div class="container-fluid">
+    <div class="navbar-header">
+        <a class="navbar-brand" href="#mainTab" data-toggle="tab">Coursier</a>
+    </div>
+
+    <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
+        <ul class="nav navbar-nav">
+            <!--  class="active" -->
+            <li><a href="#demo" data-toggle="tab">Demo</a></li>
+            <li><a href="https://github.com/alexarchambault/coursier/blob/master/USAGE.md">Usage</a></li>
+            <!-- <li class="dropdown">
+                <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Usage <span class="caret"></span></a>
+                <ul class="dropdown-menu">
+                    <li><a href="#usageCli" data-toggle="tab">Command-line</a></li>
+                    <li><a href="#usageApi" data-toggle="tab">API</a></li>
+                </ul>
+            </li> -->
+        </ul>
+
+        <ul class="nav navbar-nav navbar-right">
+            <li><a href="https://github.com/alexarchambault/coursier">Github</a></li>
+        </ul>
+    </div>
+
+  </div>
+</nav>
+
+<div class="tab-content" id="mainTabContent">
+
+    <div class="tab-pane fade in active" id="mainTab">
+        <div class="jumbotron">
+            <h1>Coursier</h1>
+            <p>Pure Scala Artifact Fetching</p>
+            <p><a href="https://github.com/alexarchambault/coursier">Project Page</a></p>
+        </div>
+
+    </div>
+
+    <div class="tab-pane fade" id="demo">
+
+        <div id="demoContent"></div>
+
+    </div>
+
+    <div class="tab-pane fade" id="usageCli">
+        <p>CLI</p>
+    </div>
+
+    <div class="tab-pane fade" id="usageApi">
+        <p>API</p>
+    </div>
+
+</div>
+
+</div>
+
+<script>
+    // From scalajs-react examples
+
+    function jsonp(url, callback) {
+        var callbackName = 'jsonp_callback_' + Math.round(100000 * Math.random());
+        window[callbackName] = function(data) {
+            delete window[callbackName];
+            callback(data);
+        };
+
+        var script = document.createElement('script');
+        script.src = url + (url.indexOf('?') >= 0 ? '&' : '?') + 'callback=' + callbackName;
+        document.body.appendChild(script);
+    }
+</script>
+
+<script type="text/javascript" src="../web-jsdeps.js"></script>
+<script type="text/javascript" src="../web-fastopt.js"></script>
+
+<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.2/jquery.min.js"></script>
+<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/js/bootstrap.min.js"></script>
+
+<script src="js/bootstrap-treeview.js"></script>
+
+<script type="text/javascript" src="js/raphael.js"></script>
+<script type="text/javascript" src="js/dracula_graph.js"></script>
+<script type="text/javascript" src="js/dracula_graffle.js"></script>
+
+<script type="text/javascript" src="js/routie.min.js"></script>
+
+<script>
+  // http://stackoverflow.com/a/13413044/3714539
+  routie({
+    demo: function() {
+        $('#accordionOne').collapse('show');
+    },
+    accordionTwo: function() {
+        $('#accordionTwo').collapse('show');
+    },
+    accordionThree: function() {
+        $('#accordionThree').collapse('show');
+    }
+  });
+</script>
+
+<script>
+  coursier.web.Main().main();
+</script>
+
+</body>
+</html>
diff --git a/web/src/main/resources/index-opt.html b/web/src/main/resources/index-opt.html
new file mode 100644
index 000000000..c1345a152
--- /dev/null
+++ b/web/src/main/resources/index-opt.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dependency resolution with Coursier</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+</head>
+<body style="margin: 0px">
+
+<div>
+    <canvas style="display: block" id="canvas" width="255" height="255"/>
+</div>
+
+<script type="text/javascript" src="../web-opt.js"></script>
+<script>
+    example.ScalaJSExample().main();
+</script>
+</body>
+</html>
diff --git a/web/src/main/resources/js/bootstrap-treeview.js b/web/src/main/resources/js/bootstrap-treeview.js
new file mode 100644
index 000000000..7a82a2eeb
--- /dev/null
+++ b/web/src/main/resources/js/bootstrap-treeview.js
@@ -0,0 +1,1249 @@
+/* =========================================================
+ * bootstrap-treeview.js v1.2.0
+ * =========================================================
+ * Copyright 2013 Jonathan Miles
+ * Project URL : http://www.jondmiles.com/bootstrap-treeview
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================= */
+
+;(function ($, window, document, undefined) {
+
+	/*global jQuery, console*/
+
+	'use strict';
+
+	var pluginName = 'treeview';
+
+	var _default = {};
+
+	_default.settings = {
+
+		injectStyle: true,
+
+		levels: 2,
+
+		expandIcon: 'glyphicon glyphicon-plus',
+		collapseIcon: 'glyphicon glyphicon-minus',
+		emptyIcon: 'glyphicon',
+		nodeIcon: '',
+		selectedIcon: '',
+		checkedIcon: 'glyphicon glyphicon-check',
+		uncheckedIcon: 'glyphicon glyphicon-unchecked',
+
+		color: undefined, // '#000000',
+		backColor: undefined, // '#FFFFFF',
+		borderColor: undefined, // '#dddddd',
+		onhoverColor: '#F5F5F5',
+		selectedColor: '#FFFFFF',
+		selectedBackColor: '#428bca',
+		searchResultColor: '#D9534F',
+		searchResultBackColor: undefined, //'#FFFFFF',
+
+		enableLinks: false,
+		highlightSelected: true,
+		highlightSearchResults: true,
+		showBorder: true,
+		showIcon: true,
+		showCheckbox: false,
+		showTags: false,
+		multiSelect: false,
+
+		// Event handlers
+		onNodeChecked: undefined,
+		onNodeCollapsed: undefined,
+		onNodeDisabled: undefined,
+		onNodeEnabled: undefined,
+		onNodeExpanded: undefined,
+		onNodeSelected: undefined,
+		onNodeUnchecked: undefined,
+		onNodeUnselected: undefined,
+		onSearchComplete: undefined,
+		onSearchCleared: undefined
+	};
+
+	_default.options = {
+		silent: false,
+		ignoreChildren: false
+	};
+
+	_default.searchOptions = {
+		ignoreCase: true,
+		exactMatch: false,
+		revealResults: true
+	};
+
+	var Tree = function (element, options) {
+
+		this.$element = $(element);
+		this.elementId = element.id;
+		this.styleId = this.elementId + '-style';
+
+		this.init(options);
+
+		return {
+
+			// Options (public access)
+			options: this.options,
+
+			// Initialize / destroy methods
+			init: $.proxy(this.init, this),
+			remove: $.proxy(this.remove, this),
+
+			// Get methods
+			getNode: $.proxy(this.getNode, this),
+			getParent: $.proxy(this.getParent, this),
+			getSiblings: $.proxy(this.getSiblings, this),
+			getSelected: $.proxy(this.getSelected, this),
+			getUnselected: $.proxy(this.getUnselected, this),
+			getExpanded: $.proxy(this.getExpanded, this),
+			getCollapsed: $.proxy(this.getCollapsed, this),
+			getChecked: $.proxy(this.getChecked, this),
+			getUnchecked: $.proxy(this.getUnchecked, this),
+			getDisabled: $.proxy(this.getDisabled, this),
+			getEnabled: $.proxy(this.getEnabled, this),
+
+			// Select methods
+			selectNode: $.proxy(this.selectNode, this),
+			unselectNode: $.proxy(this.unselectNode, this),
+			toggleNodeSelected: $.proxy(this.toggleNodeSelected, this),
+
+			// Expand / collapse methods
+			collapseAll: $.proxy(this.collapseAll, this),
+			collapseNode: $.proxy(this.collapseNode, this),
+			expandAll: $.proxy(this.expandAll, this),
+			expandNode: $.proxy(this.expandNode, this),
+			toggleNodeExpanded: $.proxy(this.toggleNodeExpanded, this),
+			revealNode: $.proxy(this.revealNode, this),
+
+			// Expand / collapse methods
+			checkAll: $.proxy(this.checkAll, this),
+			checkNode: $.proxy(this.checkNode, this),
+			uncheckAll: $.proxy(this.uncheckAll, this),
+			uncheckNode: $.proxy(this.uncheckNode, this),
+			toggleNodeChecked: $.proxy(this.toggleNodeChecked, this),
+
+			// Disable / enable methods
+			disableAll: $.proxy(this.disableAll, this),
+			disableNode: $.proxy(this.disableNode, this),
+			enableAll: $.proxy(this.enableAll, this),
+			enableNode: $.proxy(this.enableNode, this),
+			toggleNodeDisabled: $.proxy(this.toggleNodeDisabled, this),
+
+			// Search methods
+			search: $.proxy(this.search, this),
+			clearSearch: $.proxy(this.clearSearch, this)
+		};
+	};
+
+	Tree.prototype.init = function (options) {
+
+		this.tree = [];
+		this.nodes = [];
+
+		if (options.data) {
+			if (typeof options.data === 'string') {
+				options.data = $.parseJSON(options.data);
+			}
+			this.tree = $.extend(true, [], options.data);
+			delete options.data;
+		}
+		this.options = $.extend({}, _default.settings, options);
+
+		this.destroy();
+		this.subscribeEvents();
+		this.setInitialStates({ nodes: this.tree }, 0);
+		this.render();
+	};
+
+	Tree.prototype.remove = function () {
+		this.destroy();
+		$.removeData(this, pluginName);
+		$('#' + this.styleId).remove();
+	};
+
+	Tree.prototype.destroy = function () {
+
+		if (!this.initialized) return;
+
+		this.$wrapper.remove();
+		this.$wrapper = null;
+
+		// Switch off events
+		this.unsubscribeEvents();
+
+		// Reset this.initialized flag
+		this.initialized = false;
+	};
+
+	Tree.prototype.unsubscribeEvents = function () {
+
+		this.$element.off('click');
+		this.$element.off('nodeChecked');
+		this.$element.off('nodeCollapsed');
+		this.$element.off('nodeDisabled');
+		this.$element.off('nodeEnabled');
+		this.$element.off('nodeExpanded');
+		this.$element.off('nodeSelected');
+		this.$element.off('nodeUnchecked');
+		this.$element.off('nodeUnselected');
+		this.$element.off('searchComplete');
+		this.$element.off('searchCleared');
+	};
+
+	Tree.prototype.subscribeEvents = function () {
+
+		this.unsubscribeEvents();
+
+		this.$element.on('click', $.proxy(this.clickHandler, this));
+
+		if (typeof (this.options.onNodeChecked) === 'function') {
+			this.$element.on('nodeChecked', this.options.onNodeChecked);
+		}
+
+		if (typeof (this.options.onNodeCollapsed) === 'function') {
+			this.$element.on('nodeCollapsed', this.options.onNodeCollapsed);
+		}
+
+		if (typeof (this.options.onNodeDisabled) === 'function') {
+			this.$element.on('nodeDisabled', this.options.onNodeDisabled);
+		}
+
+		if (typeof (this.options.onNodeEnabled) === 'function') {
+			this.$element.on('nodeEnabled', this.options.onNodeEnabled);
+		}
+
+		if (typeof (this.options.onNodeExpanded) === 'function') {
+			this.$element.on('nodeExpanded', this.options.onNodeExpanded);
+		}
+
+		if (typeof (this.options.onNodeSelected) === 'function') {
+			this.$element.on('nodeSelected', this.options.onNodeSelected);
+		}
+
+		if (typeof (this.options.onNodeUnchecked) === 'function') {
+			this.$element.on('nodeUnchecked', this.options.onNodeUnchecked);
+		}
+
+		if (typeof (this.options.onNodeUnselected) === 'function') {
+			this.$element.on('nodeUnselected', this.options.onNodeUnselected);
+		}
+
+		if (typeof (this.options.onSearchComplete) === 'function') {
+			this.$element.on('searchComplete', this.options.onSearchComplete);
+		}
+
+		if (typeof (this.options.onSearchCleared) === 'function') {
+			this.$element.on('searchCleared', this.options.onSearchCleared);
+		}
+	};
+
+	/*
+		Recurse the tree structure and ensure all nodes have
+		valid initial states.  User defined states will be preserved.
+		For performance we also take this opportunity to
+		index nodes in a flattened structure
+	*/
+	Tree.prototype.setInitialStates = function (node, level) {
+
+		if (!node.nodes) return;
+		level += 1;
+
+		var parent = node;
+		var _this = this;
+		$.each(node.nodes, function checkStates(index, node) {
+
+			// nodeId : unique, incremental identifier
+			node.nodeId = _this.nodes.length;
+
+			// parentId : transversing up the tree
+			node.parentId = parent.nodeId;
+
+			// if not provided set selectable default value
+			if (!node.hasOwnProperty('selectable')) {
+				node.selectable = true;
+			}
+
+			// where provided we should preserve states
+			node.state = node.state || {};
+
+			// set checked state; unless set always false
+			if (!node.state.hasOwnProperty('checked')) {
+				node.state.checked = false;
+			}
+
+			// set enabled state; unless set always false
+			if (!node.state.hasOwnProperty('disabled')) {
+				node.state.disabled = false;
+			}
+
+			// set expanded state; if not provided based on levels
+			if (!node.state.hasOwnProperty('expanded')) {
+				if (!node.state.disabled &&
+						(level < _this.options.levels) &&
+						(node.nodes && node.nodes.length > 0)) {
+					node.state.expanded = true;
+				}
+				else {
+					node.state.expanded = false;
+				}
+			}
+
+			// set selected state; unless set always false
+			if (!node.state.hasOwnProperty('selected')) {
+				node.state.selected = false;
+			}
+
+			// index nodes in a flattened structure for use later
+			_this.nodes.push(node);
+
+			// recurse child nodes and transverse the tree
+			if (node.nodes) {
+				_this.setInitialStates(node, level);
+			}
+		});
+	};
+
+	Tree.prototype.clickHandler = function (event) {
+
+		if (!this.options.enableLinks) event.preventDefault();
+
+		var target = $(event.target);
+		var node = this.findNode(target);
+		if (!node || node.state.disabled) return;
+		
+		var classList = target.attr('class') ? target.attr('class').split(' ') : [];
+		if ((classList.indexOf('expand-icon') !== -1)) {
+
+			this.toggleExpandedState(node, _default.options);
+			this.render();
+		}
+		else if ((classList.indexOf('check-icon') !== -1)) {
+			
+			this.toggleCheckedState(node, _default.options);
+			this.render();
+		}
+		else {
+			
+			if (node.selectable) {
+				this.toggleSelectedState(node, _default.options);
+			} else {
+				this.toggleExpandedState(node, _default.options);
+			}
+
+			this.render();
+		}
+	};
+
+	// Looks up the DOM for the closest parent list item to retrieve the
+	// data attribute nodeid, which is used to lookup the node in the flattened structure.
+	Tree.prototype.findNode = function (target) {
+
+		var nodeId = target.closest('li.list-group-item').attr('data-nodeid');
+		var node = this.nodes[nodeId];
+
+		if (!node) {
+			console.log('Error: node does not exist');
+		}
+		return node;
+	};
+
+	Tree.prototype.toggleExpandedState = function (node, options) {
+		if (!node) return;
+		this.setExpandedState(node, !node.state.expanded, options);
+	};
+
+	Tree.prototype.setExpandedState = function (node, state, options) {
+
+		if (state === node.state.expanded) return;
+
+		if (state && node.nodes) {
+
+			// Expand a node
+			node.state.expanded = true;
+			if (!options.silent) {
+				this.$element.trigger('nodeExpanded', $.extend(true, {}, node));
+			}
+		}
+		else if (!state) {
+
+			// Collapse a node
+			node.state.expanded = false;
+			if (!options.silent) {
+				this.$element.trigger('nodeCollapsed', $.extend(true, {}, node));
+			}
+
+			// Collapse child nodes
+			if (node.nodes && !options.ignoreChildren) {
+				$.each(node.nodes, $.proxy(function (index, node) {
+					this.setExpandedState(node, false, options);
+				}, this));
+			}
+		}
+	};
+
+	Tree.prototype.toggleSelectedState = function (node, options) {
+		if (!node) return;
+		this.setSelectedState(node, !node.state.selected, options);
+	};
+
+	Tree.prototype.setSelectedState = function (node, state, options) {
+
+		if (state === node.state.selected) return;
+
+		if (state) {
+
+			// If multiSelect false, unselect previously selected
+			if (!this.options.multiSelect) {
+				$.each(this.findNodes('true', 'g', 'state.selected'), $.proxy(function (index, node) {
+					this.setSelectedState(node, false, options);
+				}, this));
+			}
+
+			// Continue selecting node
+			node.state.selected = true;
+			if (!options.silent) {
+				this.$element.trigger('nodeSelected', $.extend(true, {}, node));
+			}
+		}
+		else {
+
+			// Unselect node
+			node.state.selected = false;
+			if (!options.silent) {
+				this.$element.trigger('nodeUnselected', $.extend(true, {}, node));
+			}
+		}
+	};
+
+	Tree.prototype.toggleCheckedState = function (node, options) {
+		if (!node) return;
+		this.setCheckedState(node, !node.state.checked, options);
+	};
+
+	Tree.prototype.setCheckedState = function (node, state, options) {
+
+		if (state === node.state.checked) return;
+
+		if (state) {
+
+			// Check node
+			node.state.checked = true;
+
+			if (!options.silent) {
+				this.$element.trigger('nodeChecked', $.extend(true, {}, node));
+			}
+		}
+		else {
+
+			// Uncheck node
+			node.state.checked = false;
+			if (!options.silent) {
+				this.$element.trigger('nodeUnchecked', $.extend(true, {}, node));
+			}
+		}
+	};
+
+	Tree.prototype.setDisabledState = function (node, state, options) {
+
+		if (state === node.state.disabled) return;
+
+		if (state) {
+
+			// Disable node
+			node.state.disabled = true;
+
+			// Disable all other states
+			this.setExpandedState(node, false, options);
+			this.setSelectedState(node, false, options);
+			this.setCheckedState(node, false, options);
+
+			if (!options.silent) {
+				this.$element.trigger('nodeDisabled', $.extend(true, {}, node));
+			}
+		}
+		else {
+
+			// Enabled node
+			node.state.disabled = false;
+			if (!options.silent) {
+				this.$element.trigger('nodeEnabled', $.extend(true, {}, node));
+			}
+		}
+	};
+
+	Tree.prototype.render = function () {
+
+		if (!this.initialized) {
+
+			// Setup first time only components
+			this.$element.addClass(pluginName);
+			this.$wrapper = $(this.template.list);
+
+			this.injectStyle();
+
+			this.initialized = true;
+		}
+
+		this.$element.empty().append(this.$wrapper.empty());
+
+		// Build tree
+		this.buildTree(this.tree, 0);
+	};
+
+	// Starting from the root node, and recursing down the
+	// structure we build the tree one node at a time
+	Tree.prototype.buildTree = function (nodes, level) {
+
+		if (!nodes) return;
+		level += 1;
+
+		var _this = this;
+		$.each(nodes, function addNodes(id, node) {
+
+			var treeItem = $(_this.template.item)
+				.addClass('node-' + _this.elementId)
+				.addClass(node.state.checked ? 'node-checked' : '')
+				.addClass(node.state.disabled ? 'node-disabled': '')
+				.addClass(node.state.selected ? 'node-selected' : '')
+				.addClass(node.searchResult ? 'search-result' : '') 
+				.attr('data-nodeid', node.nodeId)
+				.attr('style', _this.buildStyleOverride(node));
+
+			// Add indent/spacer to mimic tree structure
+			for (var i = 0; i < (level - 1); i++) {
+				treeItem.append(_this.template.indent);
+			}
+
+			// Add expand, collapse or empty spacer icons
+			var classList = [];
+			if (node.nodes) {
+				classList.push('expand-icon');
+				if (node.state.expanded) {
+					classList.push(_this.options.collapseIcon);
+				}
+				else {
+					classList.push(_this.options.expandIcon);
+				}
+			}
+			else {
+				classList.push(_this.options.emptyIcon);
+			}
+
+			treeItem
+				.append($(_this.template.icon)
+					.addClass(classList.join(' '))
+				);
+
+
+			// Add node icon
+			if (_this.options.showIcon) {
+				
+				var classList = ['node-icon'];
+
+				classList.push(node.icon || _this.options.nodeIcon);
+				if (node.state.selected) {
+					classList.pop();
+					classList.push(node.selectedIcon || _this.options.selectedIcon || 
+									node.icon || _this.options.nodeIcon);
+				}
+
+				treeItem
+					.append($(_this.template.icon)
+						.addClass(classList.join(' '))
+					);
+			}
+
+			// Add check / unchecked icon
+			if (_this.options.showCheckbox) {
+
+				var classList = ['check-icon'];
+				if (node.state.checked) {
+					classList.push(_this.options.checkedIcon); 
+				}
+				else {
+					classList.push(_this.options.uncheckedIcon);
+				}
+
+				treeItem
+					.append($(_this.template.icon)
+						.addClass(classList.join(' '))
+					);
+			}
+
+			// Add text
+			if (_this.options.enableLinks) {
+				// Add hyperlink
+				treeItem
+					.append($(_this.template.link)
+						.attr('href', node.href)
+						.append(node.text)
+					);
+			}
+			else {
+				// otherwise just text
+				treeItem
+					.append(node.text);
+			}
+
+			// Add tags as badges
+			if (_this.options.showTags && node.tags) {
+				$.each(node.tags, function addTag(id, tag) {
+					treeItem
+						.append($(_this.template.badge)
+							.append(tag)
+						);
+				});
+			}
+
+			// Add item to the tree
+			_this.$wrapper.append(treeItem);
+
+			// Recursively add child ndoes
+			if (node.nodes && node.state.expanded && !node.state.disabled) {
+				return _this.buildTree(node.nodes, level);
+			}
+		});
+	};
+
+	// Define any node level style override for
+	// 1. selectedNode
+	// 2. node|data assigned color overrides
+	Tree.prototype.buildStyleOverride = function (node) {
+
+		if (node.state.disabled) return '';
+
+		var color = node.color;
+		var backColor = node.backColor;
+
+		if (this.options.highlightSelected && node.state.selected) {
+			if (this.options.selectedColor) {
+				color = this.options.selectedColor;
+			}
+			if (this.options.selectedBackColor) {
+				backColor = this.options.selectedBackColor;
+			}
+		}
+
+		if (this.options.highlightSearchResults && node.searchResult && !node.state.disabled) {
+			if (this.options.searchResultColor) {
+				color = this.options.searchResultColor;
+			}
+			if (this.options.searchResultBackColor) {
+				backColor = this.options.searchResultBackColor;
+			}
+		}
+
+		return 'color:' + color +
+			';background-color:' + backColor + ';';
+	};
+
+	// Add inline style into head
+	Tree.prototype.injectStyle = function () {
+
+		if (this.options.injectStyle && !document.getElementById(this.styleId)) {
+			$('<style type="text/css" id="' + this.styleId + '"> ' + this.buildStyle() + ' </style>').appendTo('head');
+		}
+	};
+
+	// Construct trees style based on user options
+	Tree.prototype.buildStyle = function () {
+
+		var style = '.node-' + this.elementId + '{';
+
+		if (this.options.color) {
+			style += 'color:' + this.options.color + ';';
+		}
+
+		if (this.options.backColor) {
+			style += 'background-color:' + this.options.backColor + ';';
+		}
+
+		if (!this.options.showBorder) {
+			style += 'border:none;';
+		}
+		else if (this.options.borderColor) {
+			style += 'border:1px solid ' + this.options.borderColor + ';';
+		}
+		style += '}';
+
+		if (this.options.onhoverColor) {
+			style += '.node-' + this.elementId + ':not(.node-disabled):hover{' +
+				'background-color:' + this.options.onhoverColor + ';' +
+			'}';
+		}
+
+		return this.css + style;
+	};
+
+	Tree.prototype.template = {
+		list: '<ul class="list-group"></ul>',
+		item: '<li class="list-group-item"></li>',
+		indent: '<span class="indent"></span>',
+		icon: '<span class="icon"></span>',
+		link: '<a href="#" style="color:inherit;"></a>',
+		badge: '<span class="badge"></span>'
+	};
+
+	Tree.prototype.css = '.treeview .list-group-item{cursor:pointer}.treeview span.indent{margin-left:10px;margin-right:10px}.treeview span.icon{width:12px;margin-right:5px}.treeview .node-disabled{color:silver;cursor:not-allowed}'
+
+
+	/**
+		Returns a single node object that matches the given node id.
+		@param {Number} nodeId - A node's unique identifier
+		@return {Object} node - Matching node
+	*/
+	Tree.prototype.getNode = function (nodeId) {
+		return this.nodes[nodeId];
+	};
+
+	/**
+		Returns the parent node of a given node, if valid otherwise returns undefined.
+		@param {Object|Number} identifier - A valid node or node id
+		@returns {Object} node - The parent node
+	*/
+	Tree.prototype.getParent = function (identifier) {
+		var node = this.identifyNode(identifier);
+		return this.nodes[node.parentId];
+	};
+
+	/**
+		Returns an array of sibling nodes for a given node, if valid otherwise returns undefined.
+		@param {Object|Number} identifier - A valid node or node id
+		@returns {Array} nodes - Sibling nodes
+	*/
+	Tree.prototype.getSiblings = function (identifier) {
+		var node = this.identifyNode(identifier);
+		var parent = this.getParent(node);
+		var nodes = parent ? parent.nodes : this.tree;
+		return nodes.filter(function (obj) {
+				return obj.nodeId !== node.nodeId;
+			});
+	};
+
+	/**
+		Returns an array of selected nodes.
+		@returns {Array} nodes - Selected nodes
+	*/
+	Tree.prototype.getSelected = function () {
+		return this.findNodes('true', 'g', 'state.selected');
+	};
+
+	/**
+		Returns an array of unselected nodes.
+		@returns {Array} nodes - Unselected nodes
+	*/
+	Tree.prototype.getUnselected = function () {
+		return this.findNodes('false', 'g', 'state.selected');
+	};
+
+	/**
+		Returns an array of expanded nodes.
+		@returns {Array} nodes - Expanded nodes
+	*/
+	Tree.prototype.getExpanded = function () {
+		return this.findNodes('true', 'g', 'state.expanded');
+	};
+
+	/**
+		Returns an array of collapsed nodes.
+		@returns {Array} nodes - Collapsed nodes
+	*/
+	Tree.prototype.getCollapsed = function () {
+		return this.findNodes('false', 'g', 'state.expanded');
+	};
+
+	/**
+		Returns an array of checked nodes.
+		@returns {Array} nodes - Checked nodes
+	*/
+	Tree.prototype.getChecked = function () {
+		return this.findNodes('true', 'g', 'state.checked');
+	};
+
+	/**
+		Returns an array of unchecked nodes.
+		@returns {Array} nodes - Unchecked nodes
+	*/
+	Tree.prototype.getUnchecked = function () {
+		return this.findNodes('false', 'g', 'state.checked');
+	};
+
+	/**
+		Returns an array of disabled nodes.
+		@returns {Array} nodes - Disabled nodes
+	*/
+	Tree.prototype.getDisabled = function () {
+		return this.findNodes('true', 'g', 'state.disabled');
+	};
+
+	/**
+		Returns an array of enabled nodes.
+		@returns {Array} nodes - Enabled nodes
+	*/
+	Tree.prototype.getEnabled = function () {
+		return this.findNodes('false', 'g', 'state.disabled');
+	};
+
+
+	/**
+		Set a node state to selected
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.selectNode = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setSelectedState(node, true, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Set a node state to unselected
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.unselectNode = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setSelectedState(node, false, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Toggles a node selected state; selecting if unselected, unselecting if selected.
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.toggleNodeSelected = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.toggleSelectedState(node, options);
+		}, this));
+
+		this.render();
+	};
+
+
+	/**
+		Collapse all tree nodes
+		@param {optional Object} options
+	*/
+	Tree.prototype.collapseAll = function (options) {
+		var identifiers = this.findNodes('true', 'g', 'state.expanded');
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setExpandedState(node, false, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Collapse a given tree node
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.collapseNode = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setExpandedState(node, false, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Expand all tree nodes
+		@param {optional Object} options
+	*/
+	Tree.prototype.expandAll = function (options) {
+		options = $.extend({}, _default.options, options);
+
+		if (options && options.levels) {
+			this.expandLevels(this.tree, options.levels, options);
+		}
+		else {
+			var identifiers = this.findNodes('false', 'g', 'state.expanded');
+			this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+				this.setExpandedState(node, true, options);
+			}, this));
+		}
+
+		this.render();
+	};
+
+	/**
+		Expand a given tree node
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.expandNode = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setExpandedState(node, true, options);
+			if (node.nodes && (options && options.levels)) {
+				this.expandLevels(node.nodes, options.levels-1, options);
+			}
+		}, this));
+
+		this.render();
+	};
+
+	Tree.prototype.expandLevels = function (nodes, level, options) {
+		options = $.extend({}, _default.options, options);
+
+		$.each(nodes, $.proxy(function (index, node) {
+			this.setExpandedState(node, (level > 0) ? true : false, options);
+			if (node.nodes) {
+				this.expandLevels(node.nodes, level-1, options);
+			}
+		}, this));
+	};
+
+	/**
+		Reveals a given tree node, expanding the tree from node to root.
+		@param {Object|Number|Array} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.revealNode = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			var parentNode = this.getParent(node);
+			while (parentNode) {
+				this.setExpandedState(parentNode, true, options);
+				parentNode = this.getParent(parentNode);
+			};
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Toggles a nodes expanded state; collapsing if expanded, expanding if collapsed.
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.toggleNodeExpanded = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.toggleExpandedState(node, options);
+		}, this));
+		
+		this.render();
+	};
+
+
+	/**
+		Check all tree nodes
+		@param {optional Object} options
+	*/
+	Tree.prototype.checkAll = function (options) {
+		var identifiers = this.findNodes('false', 'g', 'state.checked');
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setCheckedState(node, true, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Check a given tree node
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.checkNode = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setCheckedState(node, true, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Uncheck all tree nodes
+		@param {optional Object} options
+	*/
+	Tree.prototype.uncheckAll = function (options) {
+		var identifiers = this.findNodes('true', 'g', 'state.checked');
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setCheckedState(node, false, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Uncheck a given tree node
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.uncheckNode = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setCheckedState(node, false, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Toggles a nodes checked state; checking if unchecked, unchecking if checked.
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.toggleNodeChecked = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.toggleCheckedState(node, options);
+		}, this));
+
+		this.render();
+	};
+
+
+	/**
+		Disable all tree nodes
+		@param {optional Object} options
+	*/
+	Tree.prototype.disableAll = function (options) {
+		var identifiers = this.findNodes('false', 'g', 'state.disabled');
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setDisabledState(node, true, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Disable a given tree node
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.disableNode = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setDisabledState(node, true, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Enable all tree nodes
+		@param {optional Object} options
+	*/
+	Tree.prototype.enableAll = function (options) {
+		var identifiers = this.findNodes('true', 'g', 'state.disabled');
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setDisabledState(node, false, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Enable a given tree node
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.enableNode = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setDisabledState(node, false, options);
+		}, this));
+
+		this.render();
+	};
+
+	/**
+		Toggles a nodes disabled state; disabling is enabled, enabling if disabled.
+		@param {Object|Number} identifiers - A valid node, node id or array of node identifiers
+		@param {optional Object} options
+	*/
+	Tree.prototype.toggleNodeDisabled = function (identifiers, options) {
+		this.forEachIdentifier(identifiers, options, $.proxy(function (node, options) {
+			this.setDisabledState(node, !node.state.disabled, options);
+		}, this));
+
+		this.render();
+	};
+
+
+	/**
+		Common code for processing multiple identifiers
+	*/
+	Tree.prototype.forEachIdentifier = function (identifiers, options, callback) {
+
+		options = $.extend({}, _default.options, options);
+
+		if (!(identifiers instanceof Array)) {
+			identifiers = [identifiers];
+		}
+
+		$.each(identifiers, $.proxy(function (index, identifier) {
+			callback(this.identifyNode(identifier), options);
+		}, this));	
+	};
+
+	/*
+		Identifies a node from either a node id or object
+	*/
+	Tree.prototype.identifyNode = function (identifier) {
+		return ((typeof identifier) === 'number') ?
+						this.nodes[identifier] :
+						identifier;
+	};
+
+	/**
+		Searches the tree for nodes (text) that match given criteria
+		@param {String} pattern - A given string to match against
+		@param {optional Object} options - Search criteria options
+		@return {Array} nodes - Matching nodes
+	*/
+	Tree.prototype.search = function (pattern, options) {
+		options = $.extend({}, _default.searchOptions, options);
+
+		this.clearSearch({ render: false });
+
+		var results = [];
+		if (pattern && pattern.length > 0) {
+
+			if (options.exactMatch) {
+				pattern = '^' + pattern + '$';
+			}
+
+			var modifier = 'g';
+			if (options.ignoreCase) {
+				modifier += 'i';
+			}
+
+			results = this.findNodes(pattern, modifier);
+
+			// Add searchResult property to all matching nodes
+			// This will be used to apply custom styles
+			// and when identifying result to be cleared
+			$.each(results, function (index, node) {
+				node.searchResult = true;
+			})
+		}
+
+		// If revealResults, then render is triggered from revealNode
+		// otherwise we just call render.
+		if (options.revealResults) {
+			this.revealNode(results);
+		}
+		else {
+			this.render();
+		}
+
+		this.$element.trigger('searchComplete', $.extend(true, {}, results));
+
+		return results;
+	};
+
+	/**
+		Clears previous search results
+	*/
+	Tree.prototype.clearSearch = function (options) {
+
+		options = $.extend({}, { render: true }, options);
+
+		var results = $.each(this.findNodes('true', 'g', 'searchResult'), function (index, node) {
+			node.searchResult = false;
+		});
+
+		if (options.render) {
+			this.render();	
+		}
+		
+		this.$element.trigger('searchCleared', $.extend(true, {}, results));
+	};
+
+	/**
+		Find nodes that match a given criteria
+		@param {String} pattern - A given string to match against
+		@param {optional String} modifier - Valid RegEx modifiers
+		@param {optional String} attribute - Attribute to compare pattern against
+		@return {Array} nodes - Nodes that match your criteria
+	*/
+	Tree.prototype.findNodes = function (pattern, modifier, attribute) {
+
+		modifier = modifier || 'g';
+		attribute = attribute || 'text';
+
+		var _this = this;
+		return $.grep(this.nodes, function (node) {
+			var val = _this.getNodeValue(node, attribute);
+			if (typeof val === 'string') {
+				return val.match(new RegExp(pattern, modifier));
+			}
+		});
+	};
+
+	/**
+		Recursive find for retrieving nested attributes values
+		All values are return as strings, unless invalid
+		@param {Object} obj - Typically a node, could be any object
+		@param {String} attr - Identifies an object property using dot notation
+		@return {String} value - Matching attributes string representation
+	*/
+	Tree.prototype.getNodeValue = function (obj, attr) {
+		var index = attr.indexOf('.');
+		if (index > 0) {
+			var _obj = obj[attr.substring(0, index)];
+			var _attr = attr.substring(index + 1, attr.length);
+			return this.getNodeValue(_obj, _attr);
+		}
+		else {
+			if (obj.hasOwnProperty(attr)) {
+				return obj[attr].toString();
+			}
+			else {
+				return undefined;
+			}
+		}
+	};
+
+	var logError = function (message) {
+		if (window.console) {
+			window.console.error(message);
+		}
+	};
+
+	// Prevent against multiple instantiations,
+	// handle updates and method calls
+	$.fn[pluginName] = function (options, args) {
+
+		var result;
+
+		this.each(function () {
+			var _this = $.data(this, pluginName);
+			if (typeof options === 'string') {
+				if (!_this) {
+					logError('Not initialized, can not call method : ' + options);
+				}
+				else if (!$.isFunction(_this[options]) || options.charAt(0) === '_') {
+					logError('No such method : ' + options);
+				}
+				else {
+					if (!(args instanceof Array)) {
+						args = [ args ];
+					}
+					result = _this[options].apply(_this, args);
+				}
+			}
+			else if (typeof options === 'boolean') {
+				result = _this;
+			}
+			else {
+				$.data(this, pluginName, new Tree(this, $.extend(true, {}, options)));
+			}
+		});
+
+		return result || this;
+	};
+
+})(jQuery, window, document);
diff --git a/web/src/main/resources/js/dracula_graffle.js b/web/src/main/resources/js/dracula_graffle.js
new file mode 100644
index 000000000..50fc7173c
--- /dev/null
+++ b/web/src/main/resources/js/dracula_graffle.js
@@ -0,0 +1,128 @@
+/**
+ * Originally grabbed from the official RaphaelJS Documentation
+ * http://raphaeljs.com/graffle.html
+ * Adopted (arrows) and commented by Philipp Strathausen http://blog.ameisenbar.de
+ * Licenced under the MIT licence.
+ */
+
+/**
+ * Usage:
+ * connect two shapes
+ * parameters:
+ *      source shape [or connection for redrawing],
+ *      target shape,
+ *      style with { fg : linecolor, bg : background color, directed: boolean }
+ * returns:
+ *      connection { draw = function() }
+ */
+Raphael.fn.connection = function Connection(obj1, obj2, style) {
+  var selfRef = this;
+  /* create and return new connection */
+  var edge = {/*
+    from : obj1,
+    to : obj2,
+    style : style,*/
+    draw : function() {
+      /* get bounding boxes of target and source */
+      var bb1 = obj1.getBBox();
+      var bb2 = obj2.getBBox();
+      var off1 = 0;
+      var off2 = 0;
+      /* coordinates for potential connection coordinates from/to the objects */
+      var p = [
+        /* NORTH 1 */
+        { x: bb1.x + bb1.width / 2, y: bb1.y - off1 },
+        /* SOUTH 1 */
+        { x: bb1.x + bb1.width / 2, y: bb1.y + bb1.height + off1 },
+        /* WEST */
+        { x: bb1.x - off1, y: bb1.y + bb1.height / 2 },
+        /* EAST  1 */
+        { x: bb1.x + bb1.width + off1, y: bb1.y + bb1.height / 2 },
+        /* NORTH 2 */
+        { x: bb2.x + bb2.width / 2, y: bb2.y - off2 },
+        /* SOUTH 2 */
+        { x: bb2.x + bb2.width / 2, y: bb2.y + bb2.height + off2 },
+        /* WEST  2 */
+        { x: bb2.x - off2, y: bb2.y + bb2.height / 2 },
+        /* EAST  2 */
+        { x: bb2.x + bb2.width + off2, y: bb2.y + bb2.height / 2 }
+      ];
+      
+      /* distances between objects and according coordinates connection */
+      var d = {}, dis = [], dx, dy;
+
+      /*
+       * find out the best connection coordinates by trying all possible ways
+       */
+      /* loop the first object's connection coordinates */
+      for (var i = 0; i < 4; i++) {
+        /* loop the seond object's connection coordinates */
+        for (var j = 4; j < 8; j++) {
+          dx = Math.abs(p[i].x - p[j].x);
+          dy = Math.abs(p[i].y - p[j].y);
+          if ((i === j - 4) || (((i !== 3 && j !== 6) || p[i].x < p[j].x) &&
+            ((i !== 2 && j !== 7) || p[i].x > p[j].x) &&
+            ((i !== 0 && j !== 5) || p[i].y > p[j].y) &&
+            ((i !== 1 && j !== 4) || p[i].y < p[j].y)))
+          {
+            dis.push(dx + dy);
+            d[dis[dis.length - 1].toFixed(3)] = [i, j];
+          }
+        }
+      }
+      var res = dis.length === 0 ? [0, 4] : d[Math.min.apply(Math, dis).toFixed(3)];
+      /* bezier path */
+      var x1 = p[res[0]].x,
+          y1 = p[res[0]].y,
+          x4 = p[res[1]].x,
+          y4 = p[res[1]].y;
+          dx = Math.max(Math.abs(x1 - x4) / 2, 10);
+          dy = Math.max(Math.abs(y1 - y4) / 2, 10);
+      var x2 = [ x1, x1, x1 - dx, x1 + dx ][res[0]].toFixed(3),
+          y2 = [ y1 - dy, y1 + dy, y1, y1 ][res[0]].toFixed(3),
+          x3 = [ 0, 0, 0, 0, x4, x4, x4 - dx, x4 + dx ][res[1]].toFixed(3),
+          y3 = [ 0, 0, 0, 0, y1 + dy, y1 - dy, y4, y4 ][res[1]].toFixed(3);
+      /* assemble path and arrow */
+      var path = [ "M" + x1.toFixed(3), y1.toFixed(3),
+          "C" + x2, y2, x3, y3, x4.toFixed(3), y4.toFixed(3) ].join(",");
+      /* arrow */
+      if(style && style.directed) {
+        // magnitude, length of the last path vector 
+        var mag = Math.sqrt((y4 - y3) * (y4 - y3) + (x4 - x3) * (x4 - x3));
+        // vector normalisation to specified length  
+        var norm = function(x,l){return (-x*(l||5)/mag);};
+        // calculate array coordinates (two lines orthogonal to the path vector) 
+        var arr = [
+          { x:(norm(x4-x3)+norm(y4-y3)+x4).toFixed(3),
+            y:(norm(y4-y3)+norm(x4-x3)+y4).toFixed(3) },
+          { x:(norm(x4-x3)-norm(y4-y3)+x4).toFixed(3),
+            y:(norm(y4-y3)-norm(x4-x3)+y4).toFixed(3) }
+        ];
+        path = path + ",M" + arr[0].x + "," + arr[0].y + ",L" + x4 + "," +
+          y4 + ",L" + arr[1].x + "," + arr[1].y;
+      }
+      /* function to be used for moving existent path(s), e.g. animate() or attr() */
+      var move = "attr";
+      /* applying path(s) */
+      edge.fg && edge.fg[move]({path:path}) ||
+          (edge.fg = selfRef.path(path)
+              .attr({ stroke: style && style.stroke || "#000", fill: "none" })
+              .toBack());
+      edge.bg && edge.bg[move]({path:path}) ||
+          style && style.fill && (edge.bg = style.fill.split &&
+              selfRef.path(path)
+              .attr({ stroke: style.fill.split("|")[0], fill: "none",
+                "stroke-width": style.fill.split("|")[1] || 3 }).toBack());
+      /* setting label */
+      style && style.label &&
+          (edge.label && edge.label.attr({x:(x1+x4)/2, y:(y1+y4)/2}) ||
+              (edge.label = selfRef.text((x1+x4)/2, (y1+y4)/2, style.label)
+                .attr({fill: "#000", "font-size": style["font-size"] || "12px"})));
+      style && style.label && style["label-style"] && edge.label &&
+          edge.label.attr(style["label-style"]);
+      style && style.callback && style.callback(edge);
+    }
+  };
+  edge.draw();
+  return edge;
+};
diff --git a/web/src/main/resources/js/dracula_graph.js b/web/src/main/resources/js/dracula_graph.js
new file mode 100644
index 000000000..1748bba4e
--- /dev/null
+++ b/web/src/main/resources/js/dracula_graph.js
@@ -0,0 +1,685 @@
+/*
+ *  Dracula Graph Layout and Drawing Framework 0.0.3alpha
+ *  (c) 2010 Johann Philipp Strathausen <strathausen@gmail.com>
+ *  http://strathausen.eu
+ *  
+ *  Contributions by Jake Stothard <stothardj@gmail.com>.
+ *
+ *  based on the Graph JavaScript framework, version 0.0.1
+ *  (c) 2006 Aslak Hellesoy <aslak.hellesoy@gmail.com>
+ *  (c) 2006 Dave Hoover <dave.hoover@gmail.com>
+ *
+ *  Ported from Graph::Layouter::Spring in
+ *    http://search.cpan.org/~pasky/Graph-Layderer-0.02/
+ *  The algorithm is based on a spring-style layouter of a Java-based social
+ *  network tracker PieSpy written by Paul Mutton <paul@jibble.org>.
+ *
+ *  This code is freely distributable under the MIT license. Commercial use is
+ *  hereby granted without any cost or restriction.
+ *
+ *  Links:
+ *
+ *  Graph Dracula JavaScript Framework:
+ *      http://graphdracula.net
+ *
+ /*--------------------------------------------------------------------------*/
+
+
+
+/*
+ * Dracula
+ */
+var Dracula = function() {
+  this.nodes = {};
+  this.edges = [];
+  this.snapshots = []; // previous graph states TODO to be implemented
+};
+var Graph = Dracula;
+Dracula.prototype = {
+  /*
+   * add a node
+   * @id          the node's ID (string or number)
+   * @content     (optional, dictionary) can contain any information that is
+   *              being interpreted by the layout algorithm or the graph
+   *              representation
+   */
+  addNode: function(id, content) {
+    /* testing if node is already existing in the graph */
+    if(this.nodes[id] === undefined) {
+      this.nodes[id] = new Dracula.Node(id, content);
+    }
+    return this.nodes[id];
+  },
+
+  addEdge: function(source, target, style) {
+    var s = this.addNode(source);
+    var t = this.addNode(target);
+    var edge = new Dracula.Edge({ source: s, target: t, style: style });
+    s.edges.push(edge);
+    this.edges.push(edge);
+    // NOTE: Even directed edges are added to both nodes.
+    t.edges.push(edge);
+    return edge;
+  },
+
+  /* TODO to be implemented
+   * Preserve a copy of the graph state (nodes, positions, ...)
+   * @comment     a comment describing the state
+   */
+  snapShot: function(comment) {
+    // FIXME
+    //var graph = new Dracula();
+    //graph.nodes = jQuery.extend(true, {}, this.nodes);
+    //graph.edges = jQuery.extend(true, {}, this.edges);
+    //this.snapshots.push({comment: comment, graph: graph});
+  },
+  removeNode: function(id) {
+    if (this.nodes[id] && this.node[id].shape) {
+      this.nodes[id].shape.remove();
+      delete this.nodes[id];
+    }
+    for(var i = 0; i < this.edges.length; i++) {
+      if (this.edges[i].source.id == id || this.edges[i].target.id == id) {
+        this.edges[i].connection.fg.remove();
+        this.edges[i].connection.label.remove();
+        this.edges.splice(i, 1);
+        i--;
+      }
+    }
+  }
+};
+
+/*
+ * Edge
+ */
+Dracula.Edge = function DraculaEdge(opts) {
+  this.source = opts.source;
+  this.target = opts.target;
+  if (opts.style) {
+    this.style = jQuery.extend(true, {}, Dracula.Edge.style, opts.style);
+  } else {
+    this.style = jQuery.extend(true, {}, Dracula.Edge.style);
+  }
+};
+Dracula.Edge.style = {
+  directed: false
+};
+Dracula.Edge.prototype = {
+  weight: 0,
+  hide: function hideEdge() {
+    this.connection.fg.hide();
+    this.connection.bg && this.bg.connection.hide();
+  }
+};
+
+/*
+ * Node
+ */
+Dracula.Node = function DraculaNode(id, node){
+  var i;
+  node = node || {};
+  node.id = id;
+  node.edges = [];
+  node.hide = function() {
+    var i;
+    this.hidden = true;
+    this.shape && this.shape.hide(); /* FIXME this is representation specific code and should be elsewhere */
+    for(i in this.edges)
+      (this.edges[i].source.id == id || this.edges[i].target == id) && this.edges[i].hide && this.edges[i].hide();
+  };
+  node.show = function() {
+    var i;
+    this.hidden = false;
+    this.shape && this.shape.show();
+    for(i in this.edges)
+      (this.edges[i].source.id == id || this.edges[i].target == id) &&
+      this.edges[i].show && this.edges[i].show();
+  };
+  return node;
+};
+Dracula.Node.prototype = {
+};
+
+/*
+ * Renderer Base Class
+ */
+Dracula.Renderer = {};
+
+/*
+ * Renderer implementation using RaphaelJS
+ */
+Dracula.Renderer.Raphael = function(element, graph, width, height) {
+  this.width = width || 400;
+  this.height = height || 400;
+  this.r = Raphael(element, this.width, this.height);
+  this.radius = 40; /* max dimension of a node */
+  this.graph = graph;
+  this.mouse_in = false;
+
+  /* TODO default node rendering function */
+  if(!this.graph.render) {
+    this.graph.render = function() {
+      return;
+    };
+  }
+  this.draw();
+};
+
+
+/* Moved this default node renderer function out of the main prototype code
+ * so it can be override by default */
+Dracula.Renderer.defaultRenderFunc = function(r, node) {
+  /* the default node drawing */
+  var color = Raphael.getColor();
+  var ellipse = r.ellipse(0, 0, 30, 20).attr({
+    fill: node.fill || color,
+    stroke: node.stroke || color,
+    "stroke-width": 2
+  });
+  /* set DOM node ID */
+  ellipse.node.id = node.id || node.label;
+  if(node.class)ellipse.node.classList.add(node.class);
+  shape = r.set().push(ellipse).push(r.text(0, 30, node.label || node.id));
+  return shape;
+};
+
+
+Dracula.Renderer.Raphael.prototype = {
+  translate: function(point) {
+    return [
+      (point[0] - this.graph.layoutMinX) * this.factorX + this.radius,
+      (point[1] - this.graph.layoutMinY) * this.factorY + this.radius
+    ];
+  },
+
+  rotate: function(point, length, angle) {
+    var dx = length * Math.cos(angle);
+    var dy = length * Math.sin(angle);
+    return [point[0]+dx, point[1]+dy];
+  },
+
+  draw: function() {
+    var i;
+    this.factorX = (this.width - 2 * this.radius) / (this.graph.layoutMaxX - this.graph.layoutMinX);
+    this.factorY = (this.height - 2 * this.radius) / (this.graph.layoutMaxY - this.graph.layoutMinY);
+    for (i in this.graph.nodes) {
+      this.drawNode(this.graph.nodes[i]);
+    }
+    for (i = 0; i < this.graph.edges.length; i++) {
+      this.drawEdge(this.graph.edges[i]);
+    }
+  },
+
+  drawNode: function(node) {
+    var point = this.translate([node.layoutPosX, node.layoutPosY]);
+    node.point = point;
+    var r = this.r;
+    var graph = this.graph;
+
+    /* if node has already been drawn, move the nodes */
+    if(node.shape) {
+      var oBBox = node.shape.getBBox();
+      var opoint = {
+        x: oBBox.x + oBBox.width / 2,
+        y: oBBox.y + oBBox.height / 2
+      };
+      node.shape.translate(
+        Math.round(point[0] - opoint.x), Math.round(point[1] - opoint.y)
+      );
+
+      this.r.safari();
+      return node;
+    }/* else, draw new nodes */
+
+    var shape;
+
+    /* if a node renderer function is provided by the user, then use it
+       or the default render function instead */
+    if(!node.render) {
+      node.render = Dracula.Renderer.defaultRenderFunc;
+    }
+    /* or check for an ajax representation of the nodes */
+    if(node.shapes) {
+      // TODO ajax representation evaluation
+    }
+
+    var selfRef = this;
+    shape = node.render(this.r, node).hide();
+
+    shape.attr({"fill-opacity": 0.6});
+    /* re-reference to the node an element belongs to, needed for dragging all elements of a node */
+    shape.items.forEach(function(item) {
+      item.set = shape;
+      item.node.style.cursor = "move";
+    });
+    shape.drag(
+      function dragMove(dx, dy, x, y) {
+        dx = this.set.ox;
+        dy = this.set.oy;
+        var bBox = this.set.getBBox();
+        var newX = x - dx + (bBox.x + bBox.width / 2);
+        var newY = y - dy + (bBox.y + bBox.height / 2);
+        var clientX =
+          x - (newX < 20 ? newX - 20 : newX > r.width - 20 ? newX - r.width + 20 : 0);
+        var clientY =
+          y - (newY < 20 ? newY - 20 : newY > r.height - 20 ? newY - r.height + 20 : 0);
+        this.set.translate(clientX - Math.round(dx), clientY - Math.round(dy));
+        for (var i in selfRef.graph.edges) {
+          selfRef.graph.edges[i] &&
+            selfRef.graph.edges[i].connection && selfRef.graph.edges[i].connection.draw();
+        }
+        r.safari();
+        this.set.ox = clientX;
+        this.set.oy = clientY;
+      },
+      function dragEnter(x, y) {
+        this.set.ox = x;
+        this.set.oy = y;
+        this.animate({ 'fill-opacity': 0.2 }, 500);
+      },
+      function dragOut() {
+        this.animate({ 'fill-opacity': 0.6 }, 500);
+      }
+    );
+
+    var box = shape.getBBox();
+    shape.translate(
+      Math.round(point[0] - (box.x + box.width / 2)),
+      Math.round(point[1] - (box.y + box.height / 2))
+    );
+    node.hidden || shape.show();
+    node.shape = shape;
+  },
+  drawEdge: function(edge) {
+    /* if this edge already exists the other way around and is undirected */
+    if(edge.backedge)
+      return;
+    if(edge.source.hidden || edge.target.hidden) {
+      edge.connection && edge.connection.fg.hide();
+      edge.connection.bg && edge.connection.bg.hide();
+      return;
+    }
+    /* if edge already has been drawn, only refresh the edge */
+    if(!edge.connection) {
+      edge.style && edge.style.callback && edge.style.callback(edge); // TODO move this somewhere else
+      edge.connection = this.r.connection(edge.source.shape, edge.target.shape, edge.style);
+      return;
+    }
+    //FIXME showing doesn't work well
+    edge.connection.fg.show();
+    edge.connection.bg && edge.connection.bg.show();
+    edge.connection.draw();
+  }
+};
+Dracula.Layout = {};
+Dracula.Layout.Spring = function(graph) {
+  this.graph = graph;
+  this.iterations = 500;
+  this.maxRepulsiveForceDistance = 6;
+  this.k = 2;
+  this.c = 0.01;
+  this.maxVertexMovement = 0.5;
+  this.layout();
+};
+Dracula.Layout.Spring.prototype = {
+  layout: function() {
+    this.layoutPrepare();
+    for (var i = 0; i < this.iterations; i++) {
+      this.layoutIteration();
+    }
+    this.layoutCalcBounds();
+  },
+
+  layoutPrepare: function() {
+    var i;
+    for (i in this.graph.nodes) {
+      var node = this.graph.nodes[i];
+      node.layoutPosX = 0;
+      node.layoutPosY = 0;
+      node.layoutForceX = 0;
+      node.layoutForceY = 0;
+    }
+
+  },
+
+  layoutCalcBounds: function() {
+    var minx = Infinity, maxx = -Infinity,
+    miny = Infinity, maxy = -Infinity;
+    var i;
+
+    for (i in this.graph.nodes) {
+      var x = this.graph.nodes[i].layoutPosX;
+      var y = this.graph.nodes[i].layoutPosY;
+
+      if(x > maxx) maxx = x;
+      if(x < minx) minx = x;
+      if(y > maxy) maxy = y;
+      if(y < miny) miny = y;
+    }
+
+    this.graph.layoutMinX = minx;
+    this.graph.layoutMaxX = maxx;
+    this.graph.layoutMinY = miny;
+    this.graph.layoutMaxY = maxy;
+  },
+
+  layoutIteration: function() {
+    // Forces on nodes due to node-node repulsions
+
+    var prev = [];
+    for(var c in this.graph.nodes) {
+      var node1 = this.graph.nodes[c];
+      for (var d in prev) {
+        var node2 = this.graph.nodes[prev[d]];
+        this.layoutRepulsive(node1, node2);
+
+      }
+      prev.push(c);
+    }
+
+    // Forces on nodes due to edge attractions
+    for (var i = 0; i < this.graph.edges.length; i++) {
+      var edge = this.graph.edges[i];
+      this.layoutAttractive(edge);
+    }
+
+    // Move by the given force
+    for (i in this.graph.nodes) {
+      var node = this.graph.nodes[i];
+      var xmove = this.c * node.layoutForceX;
+      var ymove = this.c * node.layoutForceY;
+
+      var max = this.maxVertexMovement;
+      if(xmove > max) xmove = max;
+      if(xmove < -max) xmove = -max;
+      if(ymove > max) ymove = max;
+      if(ymove < -max) ymove = -max;
+
+      node.layoutPosX += xmove;
+      node.layoutPosY += ymove;
+      node.layoutForceX = 0;
+      node.layoutForceY = 0;
+    }
+  },
+
+  layoutRepulsive: function(node1, node2) {
+    if (typeof node1 == 'undefined' || typeof node2 == 'undefined')
+      return;
+    var dx = node2.layoutPosX - node1.layoutPosX;
+    var dy = node2.layoutPosY - node1.layoutPosY;
+    var d2 = dx * dx + dy * dy;
+    if(d2 < 0.01) {
+      dx = 0.1 * Math.random() + 0.1;
+      dy = 0.1 * Math.random() + 0.1;
+      d2 = dx * dx + dy * dy;
+    }
+    var d = Math.sqrt(d2);
+    if(d < this.maxRepulsiveForceDistance) {
+      var repulsiveForce = this.k * this.k / d;
+      node2.layoutForceX += repulsiveForce * dx / d;
+      node2.layoutForceY += repulsiveForce * dy / d;
+      node1.layoutForceX -= repulsiveForce * dx / d;
+      node1.layoutForceY -= repulsiveForce * dy / d;
+    }
+  },
+
+  layoutAttractive: function(edge) {
+    var node1 = edge.source;
+    var node2 = edge.target;
+
+    var dx = node2.layoutPosX - node1.layoutPosX;
+    var dy = node2.layoutPosY - node1.layoutPosY;
+    var d2 = dx * dx + dy * dy;
+    if(d2 < 0.01) {
+      dx = 0.1 * Math.random() + 0.1;
+      dy = 0.1 * Math.random() + 0.1;
+      d2 = dx * dx + dy * dy;
+    }
+    var d = Math.sqrt(d2);
+    if(d > this.maxRepulsiveForceDistance) {
+      d = this.maxRepulsiveForceDistance;
+      d2 = d * d;
+    }
+    var attractiveForce = (d2 - this.k * this.k) / this.k;
+    if(edge.attraction === undefined) edge.attraction = 1;
+    attractiveForce *= Math.log(edge.attraction) * 0.5 + 1;
+
+    node2.layoutForceX -= attractiveForce * dx / d;
+    node2.layoutForceY -= attractiveForce * dy / d;
+    node1.layoutForceX += attractiveForce * dx / d;
+    node1.layoutForceY += attractiveForce * dy / d;
+  }
+};
+
+Dracula.Layout.Ordered = function(graph, order) {
+  this.graph = graph;
+  this.order = order;
+  this.layout();
+};
+Dracula.Layout.Ordered.prototype = {
+  layout: function() {
+    this.layoutPrepare();
+    this.layoutCalcBounds();
+  },
+
+  layoutPrepare: function(order) {
+    var node, i;
+    for (i in this.graph.nodes) {
+      node = this.graph.nodes[i];
+      node.layoutPosX = 0;
+      node.layoutPosY = 0;
+    }
+    var counter = 0;
+    for (i in this.order) {
+      node = this.order[i];
+      node.layoutPosX = counter;
+      node.layoutPosY = Math.random();
+      counter++;
+    }
+  },
+
+  layoutCalcBounds: function() {
+    var minx = Infinity, maxx = -Infinity,
+    miny = Infinity, maxy = -Infinity;
+    var i;
+
+    for (i in this.graph.nodes) {
+      var x = this.graph.nodes[i].layoutPosX;
+      var y = this.graph.nodes[i].layoutPosY;
+
+      if(x > maxx) maxx = x;
+      if(x < minx) minx = x;
+      if(y > maxy) maxy = y;
+      if(y < miny) miny = y;
+    }
+
+    this.graph.layoutMinX = minx;
+    this.graph.layoutMaxX = maxx;
+
+    this.graph.layoutMinY = miny;
+    this.graph.layoutMaxY = maxy;
+  }
+};
+
+
+Dracula.Layout.OrderedTree = function(graph, order) {
+  this.graph = graph;
+  this.order = order;
+  this.layout();
+};
+
+/*
+ * OrderedTree is like Ordered but assumes there is one root
+ * This way we can give non random positions to nodes on the Y-axis
+ * it assumes the ordered nodes are of a perfect binary tree
+ */
+Dracula.Layout.OrderedTree.prototype = {
+  layout: function() {
+    this.layoutPrepare();
+    this.layoutCalcBounds();
+  },
+
+  layoutPrepare: function(order) {
+    var node, i;
+    for (i in this.graph.nodes) {
+      node = this.graph.nodes[i];
+      node.layoutPosX = 0;
+      node.layoutPosY = 0;
+    }
+    //to reverse the order of rendering, we need to find out the
+    //absolute number of levels we have. simple log math applies.
+    var numNodes = this.order.length;
+    var totalLevels = Math.floor(Math.log(numNodes) / Math.log(2));
+
+    var counter = 1;
+    for (i in this.order) {
+      node = this.order[i];
+      //rank aka x coordinate
+      var rank = Math.floor(Math.log(counter) / Math.log(2));
+      //file relative to top
+      var file = counter - Math.pow(rank, 2);
+
+      node.layoutPosX = totalLevels - rank;
+      node.layoutPosY = file;
+      counter++;
+    }
+  },
+
+  layoutCalcBounds: function() {
+    var minx = Infinity, maxx = -Infinity,
+    miny = Infinity, maxy = -Infinity;
+    var i;
+
+    for (i in this.graph.nodes) {
+      var x = this.graph.nodes[i].layoutPosX;
+      var y = this.graph.nodes[i].layoutPosY;
+
+      if(x > maxx) maxx = x;
+      if(x < minx) minx = x;
+      if(y > maxy) maxy = y;
+      if(y < miny) miny = y;
+    }
+
+    this.graph.layoutMinX = minx;
+    this.graph.layoutMaxX = maxx;
+
+    this.graph.layoutMinY = miny;
+    this.graph.layoutMaxY = maxy;
+  }
+};
+
+
+Dracula.Layout.TournamentTree = function(graph, order) {
+  this.graph = graph;
+  this.order = order;
+  this.layout();
+};
+
+
+/*
+ * TournamentTree looks more like a binary tree
+ */
+Dracula.Layout.TournamentTree.prototype = {
+  layout: function() {
+    this.layoutPrepare();
+    this.layoutCalcBounds();
+  },
+
+  layoutPrepare: function(order) {
+    var node, i;
+    for (i in this.graph.nodes) {
+      node = this.graph.nodes[i];
+      node.layoutPosX = 0;
+      node.layoutPosY = 0;
+    }
+    //to reverse the order of rendering, we need to find out the
+    //absolute number of levels we have. simple log math applies.
+    var numNodes = this.order.length;
+    var totalLevels = Math.floor(Math.log(numNodes) / Math.log(2));
+
+    var counter = 1;
+    for (i in this.order) {
+      node = this.order[i];
+      var depth = Math.floor(Math.log(counter) / Math.log(2));
+      var xpos = counter - Math.pow(depth, 2);
+      var offset = Math.pow(2, totalLevels - depth);
+      var final_x = offset + (counter - Math.pow(2, depth)) *
+        Math.pow(2, (totalLevels - depth) + 1);
+      node.layoutPosX = final_x;
+      node.layoutPosY = depth;
+      counter++;
+    }
+  },
+
+  layoutCalcBounds: function() {
+    var minx = Infinity, maxx = -Infinity,
+    miny = Infinity, maxy = -Infinity;
+    var i;
+
+    for (i in this.graph.nodes) {
+      var x = this.graph.nodes[i].layoutPosX;
+      var y = this.graph.nodes[i].layoutPosY;
+
+      if(x > maxx) maxx = x;
+      if(x < minx) minx = x;
+      if(y > maxy) maxy = y;
+      if(y < miny) miny = y;
+    }
+
+    this.graph.layoutMinX = minx;
+    this.graph.layoutMaxX = maxx;
+
+    this.graph.layoutMinY = miny;
+    this.graph.layoutMaxY = maxy;
+  }
+};
+
+
+/*
+ * Raphael Tooltip Plugin
+ * - attaches an element as a tooltip to another element
+ *
+ * Usage example, adding a rectangle as a tooltip to a circle:
+ *
+ *      paper.circle(100,100,10).tooltip(paper.rect(0,0,20,30));
+ *
+ * If you want to use more shapes, you'll have to put them into a set.
+ *
+ */
+Raphael.el.tooltip = function (tp) {
+    this.tp = tp;
+    this.tp.o = {x: 0, y: 0};
+    this.tp.hide();
+    this.hover(
+        function(event){
+            this.mousemove(function(event){
+                this.tp.translate(event.clientX -
+                                  this.tp.o.x,event.clientY - this.tp.o.y);
+                this.tp.o = {x: event.clientX, y: event.clientY};
+            });
+            this.tp.show().toFront();
+        },
+        function(event){
+            this.tp.hide();
+            this.unmousemove();
+        });
+    return this;
+};
+
+/* For IE */
+if (!Array.prototype.forEach)
+{
+  Array.prototype.forEach = function(fun /*, thisp*/)
+  {
+    var len = this.length;
+    if (typeof fun != "function")
+      throw new TypeError();
+
+    var thisp = arguments[1];
+    for (var i = 0; i < len; i++)
+    {
+      if (i in this)
+        fun.call(thisp, this[i], i, this);
+    }
+  };
+}
diff --git a/web/src/main/resources/js/raphael.js b/web/src/main/resources/js/raphael.js
new file mode 100644
index 000000000..ad81bd35f
--- /dev/null
+++ b/web/src/main/resources/js/raphael.js
@@ -0,0 +1,8117 @@
+// ┌────────────────────────────────────────────────────────────────────┐ \\
+// │ Raphaël 2.1.2 - JavaScript Vector Library                          │ \\
+// ├────────────────────────────────────────────────────────────────────┤ \\
+// │ Copyright © 2008-2012 Dmitry Baranovskiy (http://raphaeljs.com)    │ \\
+// │ Copyright © 2008-2012 Sencha Labs (http://sencha.com)              │ \\
+// ├────────────────────────────────────────────────────────────────────┤ \\
+// │ Licensed under the MIT (http://raphaeljs.com/license.html) license.│ \\
+// └────────────────────────────────────────────────────────────────────┘ \\
+// Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ┌────────────────────────────────────────────────────────────┐ \\
+// │ Eve 0.4.2 - JavaScript Events Library                      │ \\
+// ├────────────────────────────────────────────────────────────┤ \\
+// │ Author Dmitry Baranovskiy (http://dmitry.baranovskiy.com/) │ \\
+// └────────────────────────────────────────────────────────────┘ \\
+
+(function (glob) {
+    var version = "0.4.2",
+        has = "hasOwnProperty",
+        separator = /[\.\/]/,
+        wildcard = "*",
+        fun = function () {},
+        numsort = function (a, b) {
+            return a - b;
+        },
+        current_event,
+        stop,
+        events = {n: {}},
+    /*\
+     * eve
+     [ method ]
+
+     * Fires event with given `name`, given scope and other parameters.
+
+     > Arguments
+
+     - name (string) name of the *event*, dot (`.`) or slash (`/`) separated
+     - scope (object) context for the event handlers
+     - varargs (...) the rest of arguments will be sent to event handlers
+
+     = (object) array of returned values from the listeners
+    \*/
+        eve = function (name, scope) {
+			name = String(name);
+            var e = events,
+                oldstop = stop,
+                args = Array.prototype.slice.call(arguments, 2),
+                listeners = eve.listeners(name),
+                z = 0,
+                f = false,
+                l,
+                indexed = [],
+                queue = {},
+                out = [],
+                ce = current_event,
+                errors = [];
+            current_event = name;
+            stop = 0;
+            for (var i = 0, ii = listeners.length; i < ii; i++) if ("zIndex" in listeners[i]) {
+                indexed.push(listeners[i].zIndex);
+                if (listeners[i].zIndex < 0) {
+                    queue[listeners[i].zIndex] = listeners[i];
+                }
+            }
+            indexed.sort(numsort);
+            while (indexed[z] < 0) {
+                l = queue[indexed[z++]];
+                out.push(l.apply(scope, args));
+                if (stop) {
+                    stop = oldstop;
+                    return out;
+                }
+            }
+            for (i = 0; i < ii; i++) {
+                l = listeners[i];
+                if ("zIndex" in l) {
+                    if (l.zIndex == indexed[z]) {
+                        out.push(l.apply(scope, args));
+                        if (stop) {
+                            break;
+                        }
+                        do {
+                            z++;
+                            l = queue[indexed[z]];
+                            l && out.push(l.apply(scope, args));
+                            if (stop) {
+                                break;
+                            }
+                        } while (l)
+                    } else {
+                        queue[l.zIndex] = l;
+                    }
+                } else {
+                    out.push(l.apply(scope, args));
+                    if (stop) {
+                        break;
+                    }
+                }
+            }
+            stop = oldstop;
+            current_event = ce;
+            return out.length ? out : null;
+        };
+		// Undocumented. Debug only.
+		eve._events = events;
+    /*\
+     * eve.listeners
+     [ method ]
+
+     * Internal method which gives you array of all event handlers that will be triggered by the given `name`.
+
+     > Arguments
+
+     - name (string) name of the event, dot (`.`) or slash (`/`) separated
+
+     = (array) array of event handlers
+    \*/
+    eve.listeners = function (name) {
+        var names = name.split(separator),
+            e = events,
+            item,
+            items,
+            k,
+            i,
+            ii,
+            j,
+            jj,
+            nes,
+            es = [e],
+            out = [];
+        for (i = 0, ii = names.length; i < ii; i++) {
+            nes = [];
+            for (j = 0, jj = es.length; j < jj; j++) {
+                e = es[j].n;
+                items = [e[names[i]], e[wildcard]];
+                k = 2;
+                while (k--) {
+                    item = items[k];
+                    if (item) {
+                        nes.push(item);
+                        out = out.concat(item.f || []);
+                    }
+                }
+            }
+            es = nes;
+        }
+        return out;
+    };
+    
+    /*\
+     * eve.on
+     [ method ]
+     **
+     * Binds given event handler with a given name. You can use wildcards “`*`” for the names:
+     | eve.on("*.under.*", f);
+     | eve("mouse.under.floor"); // triggers f
+     * Use @eve to trigger the listener.
+     **
+     > Arguments
+     **
+     - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards
+     - f (function) event handler function
+     **
+     = (function) returned function accepts a single numeric parameter that represents z-index of the handler. It is an optional feature and only used when you need to ensure that some subset of handlers will be invoked in a given order, despite of the order of assignment. 
+     > Example:
+     | eve.on("mouse", eatIt)(2);
+     | eve.on("mouse", scream);
+     | eve.on("mouse", catchIt)(1);
+     * This will ensure that `catchIt()` function will be called before `eatIt()`.
+	 *
+     * If you want to put your handler before non-indexed handlers, specify a negative value.
+     * Note: I assume most of the time you don’t need to worry about z-index, but it’s nice to have this feature “just in case”.
+    \*/
+    eve.on = function (name, f) {
+		name = String(name);
+		if (typeof f != "function") {
+			return function () {};
+		}
+        var names = name.split(separator),
+            e = events;
+        for (var i = 0, ii = names.length; i < ii; i++) {
+            e = e.n;
+            e = e.hasOwnProperty(names[i]) && e[names[i]] || (e[names[i]] = {n: {}});
+        }
+        e.f = e.f || [];
+        for (i = 0, ii = e.f.length; i < ii; i++) if (e.f[i] == f) {
+            return fun;
+        }
+        e.f.push(f);
+        return function (zIndex) {
+            if (+zIndex == +zIndex) {
+                f.zIndex = +zIndex;
+            }
+        };
+    };
+    /*\
+     * eve.f
+     [ method ]
+     **
+     * Returns function that will fire given event with optional arguments.
+	 * Arguments that will be passed to the result function will be also
+	 * concated to the list of final arguments.
+ 	 | el.onclick = eve.f("click", 1, 2);
+ 	 | eve.on("click", function (a, b, c) {
+ 	 |     console.log(a, b, c); // 1, 2, [event object]
+ 	 | });
+     > Arguments
+	 - event (string) event name
+	 - varargs (…) and any other arguments
+	 = (function) possible event handler function
+    \*/
+	eve.f = function (event) {
+		var attrs = [].slice.call(arguments, 1);
+		return function () {
+			eve.apply(null, [event, null].concat(attrs).concat([].slice.call(arguments, 0)));
+		};
+	};
+    /*\
+     * eve.stop
+     [ method ]
+     **
+     * Is used inside an event handler to stop the event, preventing any subsequent listeners from firing.
+    \*/
+    eve.stop = function () {
+        stop = 1;
+    };
+    /*\
+     * eve.nt
+     [ method ]
+     **
+     * Could be used inside event handler to figure out actual name of the event.
+     **
+     > Arguments
+     **
+     - subname (string) #optional subname of the event
+     **
+     = (string) name of the event, if `subname` is not specified
+     * or
+     = (boolean) `true`, if current event’s name contains `subname`
+    \*/
+    eve.nt = function (subname) {
+        if (subname) {
+            return new RegExp("(?:\\.|\\/|^)" + subname + "(?:\\.|\\/|$)").test(current_event);
+        }
+        return current_event;
+    };
+    /*\
+     * eve.nts
+     [ method ]
+     **
+     * Could be used inside event handler to figure out actual name of the event.
+     **
+     **
+     = (array) names of the event
+    \*/
+    eve.nts = function () {
+        return current_event.split(separator);
+    };
+    /*\
+     * eve.off
+     [ method ]
+     **
+     * Removes given function from the list of event listeners assigned to given name.
+	 * If no arguments specified all the events will be cleared.
+     **
+     > Arguments
+     **
+     - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards
+     - f (function) event handler function
+    \*/
+    /*\
+     * eve.unbind
+     [ method ]
+     **
+     * See @eve.off
+    \*/
+    eve.off = eve.unbind = function (name, f) {
+		if (!name) {
+		    eve._events = events = {n: {}};
+			return;
+		}
+        var names = name.split(separator),
+            e,
+            key,
+            splice,
+            i, ii, j, jj,
+            cur = [events];
+        for (i = 0, ii = names.length; i < ii; i++) {
+            for (j = 0; j < cur.length; j += splice.length - 2) {
+                splice = [j, 1];
+                e = cur[j].n;
+                if (names[i] != wildcard) {
+                    if (e[names[i]]) {
+                        splice.push(e[names[i]]);
+                    }
+                } else {
+                    for (key in e) if (e[has](key)) {
+                        splice.push(e[key]);
+                    }
+                }
+                cur.splice.apply(cur, splice);
+            }
+        }
+        for (i = 0, ii = cur.length; i < ii; i++) {
+            e = cur[i];
+            while (e.n) {
+                if (f) {
+                    if (e.f) {
+                        for (j = 0, jj = e.f.length; j < jj; j++) if (e.f[j] == f) {
+                            e.f.splice(j, 1);
+                            break;
+                        }
+                        !e.f.length && delete e.f;
+                    }
+                    for (key in e.n) if (e.n[has](key) && e.n[key].f) {
+                        var funcs = e.n[key].f;
+                        for (j = 0, jj = funcs.length; j < jj; j++) if (funcs[j] == f) {
+                            funcs.splice(j, 1);
+                            break;
+                        }
+                        !funcs.length && delete e.n[key].f;
+                    }
+                } else {
+                    delete e.f;
+                    for (key in e.n) if (e.n[has](key) && e.n[key].f) {
+                        delete e.n[key].f;
+                    }
+                }
+                e = e.n;
+            }
+        }
+    };
+    /*\
+     * eve.once
+     [ method ]
+     **
+     * Binds given event handler with a given name to only run once then unbind itself.
+     | eve.once("login", f);
+     | eve("login"); // triggers f
+     | eve("login"); // no listeners
+     * Use @eve to trigger the listener.
+     **
+     > Arguments
+     **
+     - name (string) name of the event, dot (`.`) or slash (`/`) separated, with optional wildcards
+     - f (function) event handler function
+     **
+     = (function) same return function as @eve.on
+    \*/
+    eve.once = function (name, f) {
+        var f2 = function () {
+            eve.unbind(name, f2);
+            return f.apply(this, arguments);
+        };
+        return eve.on(name, f2);
+    };
+    /*\
+     * eve.version
+     [ property (string) ]
+     **
+     * Current version of the library.
+    \*/
+    eve.version = version;
+    eve.toString = function () {
+        return "You are running Eve " + version;
+    };
+    (typeof module != "undefined" && module.exports) ? (module.exports = eve) : (typeof define != "undefined" ? (define("eve", [], function() { return eve; })) : (glob.eve = eve));
+})(window || this);
+// ┌─────────────────────────────────────────────────────────────────────┐ \\
+// │ "Raphaël 2.1.2" - JavaScript Vector Library                         │ \\
+// ├─────────────────────────────────────────────────────────────────────┤ \\
+// │ Copyright (c) 2008-2011 Dmitry Baranovskiy (http://raphaeljs.com)   │ \\
+// │ Copyright (c) 2008-2011 Sencha Labs (http://sencha.com)             │ \\
+// │ Licensed under the MIT (http://raphaeljs.com/license.html) license. │ \\
+// └─────────────────────────────────────────────────────────────────────┘ \\
+
+(function (glob, factory) {
+    // AMD support
+    if (typeof define === "function" && define.amd) {
+        // Define as an anonymous module
+        define(["eve"], function( eve ) {
+            return factory(glob, eve);
+        });
+    } else {
+        // Browser globals (glob is window)
+        // Raphael adds itself to window
+        factory(glob, glob.eve);
+    }
+}(this, function (window, eve) {
+    /*\
+     * Raphael
+     [ method ]
+     **
+     * Creates a canvas object on which to draw.
+     * You must do this first, as all future calls to drawing methods
+     * from this instance will be bound to this canvas.
+     > Parameters
+     **
+     - container (HTMLElement|string) DOM element or its ID which is going to be a parent for drawing surface
+     - width (number)
+     - height (number)
+     - callback (function) #optional callback function which is going to be executed in the context of newly created paper
+     * or
+     - x (number)
+     - y (number)
+     - width (number)
+     - height (number)
+     - callback (function) #optional callback function which is going to be executed in the context of newly created paper
+     * or
+     - all (array) (first 3 or 4 elements in the array are equal to [containerID, width, height] or [x, y, width, height]. The rest are element descriptions in format {type: type, <attributes>}). See @Paper.add.
+     - callback (function) #optional callback function which is going to be executed in the context of newly created paper
+     * or
+     - onReadyCallback (function) function that is going to be called on DOM ready event. You can also subscribe to this event via Eve’s “DOMLoad” event. In this case method returns `undefined`.
+     = (object) @Paper
+     > Usage
+     | // Each of the following examples create a canvas
+     | // that is 320px wide by 200px high.
+     | // Canvas is created at the viewport’s 10,50 coordinate.
+     | var paper = Raphael(10, 50, 320, 200);
+     | // Canvas is created at the top left corner of the #notepad element
+     | // (or its top right corner in dir="rtl" elements)
+     | var paper = Raphael(document.getElementById("notepad"), 320, 200);
+     | // Same as above
+     | var paper = Raphael("notepad", 320, 200);
+     | // Image dump
+     | var set = Raphael(["notepad", 320, 200, {
+     |     type: "rect",
+     |     x: 10,
+     |     y: 10,
+     |     width: 25,
+     |     height: 25,
+     |     stroke: "#f00"
+     | }, {
+     |     type: "text",
+     |     x: 30,
+     |     y: 40,
+     |     text: "Dump"
+     | }]);
+    \*/
+    function R(first) {
+        if (R.is(first, "function")) {
+            return loaded ? first() : eve.on("raphael.DOMload", first);
+        } else if (R.is(first, array)) {
+            return R._engine.create[apply](R, first.splice(0, 3 + R.is(first[0], nu))).add(first);
+        } else {
+            var args = Array.prototype.slice.call(arguments, 0);
+            if (R.is(args[args.length - 1], "function")) {
+                var f = args.pop();
+                return loaded ? f.call(R._engine.create[apply](R, args)) : eve.on("raphael.DOMload", function () {
+                    f.call(R._engine.create[apply](R, args));
+                });
+            } else {
+                return R._engine.create[apply](R, arguments);
+            }
+        }
+    }
+    R.version = "2.1.2";
+    R.eve = eve;
+    var loaded,
+        separator = /[, ]+/,
+        elements = {circle: 1, rect: 1, path: 1, ellipse: 1, text: 1, image: 1},
+        formatrg = /\{(\d+)\}/g,
+        proto = "prototype",
+        has = "hasOwnProperty",
+        g = {
+            doc: document,
+            win: window
+        },
+        oldRaphael = {
+            was: Object.prototype[has].call(g.win, "Raphael"),
+            is: g.win.Raphael
+        },
+        Paper = function () {
+            /*\
+             * Paper.ca
+             [ property (object) ]
+             **
+             * Shortcut for @Paper.customAttributes
+            \*/
+            /*\
+             * Paper.customAttributes
+             [ property (object) ]
+             **
+             * If you have a set of attributes that you would like to represent
+             * as a function of some number you can do it easily with custom attributes:
+             > Usage
+             | paper.customAttributes.hue = function (num) {
+             |     num = num % 1;
+             |     return {fill: "hsb(" + num + ", 0.75, 1)"};
+             | };
+             | // Custom attribute “hue” will change fill
+             | // to be given hue with fixed saturation and brightness.
+             | // Now you can use it like this:
+             | var c = paper.circle(10, 10, 10).attr({hue: .45});
+             | // or even like this:
+             | c.animate({hue: 1}, 1e3);
+             | 
+             | // You could also create custom attribute
+             | // with multiple parameters:
+             | paper.customAttributes.hsb = function (h, s, b) {
+             |     return {fill: "hsb(" + [h, s, b].join(",") + ")"};
+             | };
+             | c.attr({hsb: "0.5 .8 1"});
+             | c.animate({hsb: [1, 0, 0.5]}, 1e3);
+            \*/
+            this.ca = this.customAttributes = {};
+        },
+        paperproto,
+        appendChild = "appendChild",
+        apply = "apply",
+        concat = "concat",
+        supportsTouch = ('ontouchstart' in g.win) || g.win.DocumentTouch && g.doc instanceof DocumentTouch, //taken from Modernizr touch test
+        E = "",
+        S = " ",
+        Str = String,
+        split = "split",
+        events = "click dblclick mousedown mousemove mouseout mouseover mouseup touchstart touchmove touchend touchcancel"[split](S),
+        touchMap = {
+            mousedown: "touchstart",
+            mousemove: "touchmove",
+            mouseup: "touchend"
+        },
+        lowerCase = Str.prototype.toLowerCase,
+        math = Math,
+        mmax = math.max,
+        mmin = math.min,
+        abs = math.abs,
+        pow = math.pow,
+        PI = math.PI,
+        nu = "number",
+        string = "string",
+        array = "array",
+        toString = "toString",
+        fillString = "fill",
+        objectToString = Object.prototype.toString,
+        paper = {},
+        push = "push",
+        ISURL = R._ISURL = /^url\(['"]?([^\)]+?)['"]?\)$/i,
+        colourRegExp = /^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgba?\(\s*([\d\.]+%?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+%?)?)\s*\)|hsba?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?)%?\s*\)|hsla?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?)%?\s*\))\s*$/i,
+        isnan = {"NaN": 1, "Infinity": 1, "-Infinity": 1},
+        bezierrg = /^(?:cubic-)?bezier\(([^,]+),([^,]+),([^,]+),([^\)]+)\)/,
+        round = math.round,
+        setAttribute = "setAttribute",
+        toFloat = parseFloat,
+        toInt = parseInt,
+        upperCase = Str.prototype.toUpperCase,
+        availableAttrs = R._availableAttrs = {
+            "arrow-end": "none",
+            "arrow-start": "none",
+            blur: 0,
+            "clip-rect": "0 0 1e9 1e9",
+            cursor: "default",
+            cx: 0,
+            cy: 0,
+            fill: "#fff",
+            "fill-opacity": 1,
+            font: '10px "Arial"',
+            "font-family": '"Arial"',
+            "font-size": "10",
+            "font-style": "normal",
+            "font-weight": 400,
+            gradient: 0,
+            height: 0,
+            href: "http://raphaeljs.com/",
+            "letter-spacing": 0,
+            opacity: 1,
+            path: "M0,0",
+            r: 0,
+            rx: 0,
+            ry: 0,
+            src: "",
+            stroke: "#000",
+            "stroke-dasharray": "",
+            "stroke-linecap": "butt",
+            "stroke-linejoin": "butt",
+            "stroke-miterlimit": 0,
+            "stroke-opacity": 1,
+            "stroke-width": 1,
+            target: "_blank",
+            "text-anchor": "middle",
+            title: "Raphael",
+            transform: "",
+            width: 0,
+            x: 0,
+            y: 0
+        },
+        availableAnimAttrs = R._availableAnimAttrs = {
+            blur: nu,
+            "clip-rect": "csv",
+            cx: nu,
+            cy: nu,
+            fill: "colour",
+            "fill-opacity": nu,
+            "font-size": nu,
+            height: nu,
+            opacity: nu,
+            path: "path",
+            r: nu,
+            rx: nu,
+            ry: nu,
+            stroke: "colour",
+            "stroke-opacity": nu,
+            "stroke-width": nu,
+            transform: "transform",
+            width: nu,
+            x: nu,
+            y: nu
+        },
+        whitespace = /[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]/g,
+        commaSpaces = /[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*/,
+        hsrg = {hs: 1, rg: 1},
+        p2s = /,?([achlmqrstvxz]),?/gi,
+        pathCommand = /([achlmrqstvz])[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*)+)/ig,
+        tCommand = /([rstm])[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*)+)/ig,
+        pathValues = /(-?\d*\.?\d*(?:e[\-+]?\d+)?)[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*/ig,
+        radial_gradient = R._radial_gradient = /^r(?:\(([^,]+?)[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*([^\)]+?)\))?/,
+        eldata = {},
+        sortByKey = function (a, b) {
+            return a.key - b.key;
+        },
+        sortByNumber = function (a, b) {
+            return toFloat(a) - toFloat(b);
+        },
+        fun = function () {},
+        pipe = function (x) {
+            return x;
+        },
+        rectPath = R._rectPath = function (x, y, w, h, r) {
+            if (r) {
+                return [["M", x + r, y], ["l", w - r * 2, 0], ["a", r, r, 0, 0, 1, r, r], ["l", 0, h - r * 2], ["a", r, r, 0, 0, 1, -r, r], ["l", r * 2 - w, 0], ["a", r, r, 0, 0, 1, -r, -r], ["l", 0, r * 2 - h], ["a", r, r, 0, 0, 1, r, -r], ["z"]];
+            }
+            return [["M", x, y], ["l", w, 0], ["l", 0, h], ["l", -w, 0], ["z"]];
+        },
+        ellipsePath = function (x, y, rx, ry) {
+            if (ry == null) {
+                ry = rx;
+            }
+            return [["M", x, y], ["m", 0, -ry], ["a", rx, ry, 0, 1, 1, 0, 2 * ry], ["a", rx, ry, 0, 1, 1, 0, -2 * ry], ["z"]];
+        },
+        getPath = R._getPath = {
+            path: function (el) {
+                return el.attr("path");
+            },
+            circle: function (el) {
+                var a = el.attrs;
+                return ellipsePath(a.cx, a.cy, a.r);
+            },
+            ellipse: function (el) {
+                var a = el.attrs;
+                return ellipsePath(a.cx, a.cy, a.rx, a.ry);
+            },
+            rect: function (el) {
+                var a = el.attrs;
+                return rectPath(a.x, a.y, a.width, a.height, a.r);
+            },
+            image: function (el) {
+                var a = el.attrs;
+                return rectPath(a.x, a.y, a.width, a.height);
+            },
+            text: function (el) {
+                var bbox = el._getBBox();
+                return rectPath(bbox.x, bbox.y, bbox.width, bbox.height);
+            },
+            set : function(el) {
+                var bbox = el._getBBox();
+                return rectPath(bbox.x, bbox.y, bbox.width, bbox.height);
+            }
+        },
+        /*\
+         * Raphael.mapPath
+         [ method ]
+         **
+         * Transform the path string with given matrix.
+         > Parameters
+         - path (string) path string
+         - matrix (object) see @Matrix
+         = (string) transformed path string
+        \*/
+        mapPath = R.mapPath = function (path, matrix) {
+            if (!matrix) {
+                return path;
+            }
+            var x, y, i, j, ii, jj, pathi;
+            path = path2curve(path);
+            for (i = 0, ii = path.length; i < ii; i++) {
+                pathi = path[i];
+                for (j = 1, jj = pathi.length; j < jj; j += 2) {
+                    x = matrix.x(pathi[j], pathi[j + 1]);
+                    y = matrix.y(pathi[j], pathi[j + 1]);
+                    pathi[j] = x;
+                    pathi[j + 1] = y;
+                }
+            }
+            return path;
+        };
+
+    R._g = g;
+    /*\
+     * Raphael.type
+     [ property (string) ]
+     **
+     * Can be “SVG”, “VML” or empty, depending on browser support.
+    \*/
+    R.type = (g.win.SVGAngle || g.doc.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") ? "SVG" : "VML");
+    if (R.type == "VML") {
+        var d = g.doc.createElement("div"),
+            b;
+        d.innerHTML = '<v:shape adj="1"/>';
+        b = d.firstChild;
+        b.style.behavior = "url(#default#VML)";
+        if (!(b && typeof b.adj == "object")) {
+            return (R.type = E);
+        }
+        d = null;
+    }
+    /*\
+     * Raphael.svg
+     [ property (boolean) ]
+     **
+     * `true` if browser supports SVG.
+    \*/
+    /*\
+     * Raphael.vml
+     [ property (boolean) ]
+     **
+     * `true` if browser supports VML.
+    \*/
+    R.svg = !(R.vml = R.type == "VML");
+    R._Paper = Paper;
+    /*\
+     * Raphael.fn
+     [ property (object) ]
+     **
+     * You can add your own method to the canvas. For example if you want to draw a pie chart,
+     * you can create your own pie chart function and ship it as a Raphaël plugin. To do this
+     * you need to extend the `Raphael.fn` object. You should modify the `fn` object before a
+     * Raphaël instance is created, otherwise it will take no effect. Please note that the
+     * ability for namespaced plugins was removed in Raphael 2.0. It is up to the plugin to
+     * ensure any namespacing ensures proper context.
+     > Usage
+     | Raphael.fn.arrow = function (x1, y1, x2, y2, size) {
+     |     return this.path( ... );
+     | };
+     | // or create namespace
+     | Raphael.fn.mystuff = {
+     |     arrow: function () {…},
+     |     star: function () {…},
+     |     // etc…
+     | };
+     | var paper = Raphael(10, 10, 630, 480);
+     | // then use it
+     | paper.arrow(10, 10, 30, 30, 5).attr({fill: "#f00"});
+     | paper.mystuff.arrow();
+     | paper.mystuff.star();
+    \*/
+    R.fn = paperproto = Paper.prototype = R.prototype;
+    R._id = 0;
+    R._oid = 0;
+    /*\
+     * Raphael.is
+     [ method ]
+     **
+     * Handfull replacement for `typeof` operator.
+     > Parameters
+     - o (…) any object or primitive
+     - type (string) name of the type, i.e. “string”, “function”, “number”, etc.
+     = (boolean) is given value is of given type
+    \*/
+    R.is = function (o, type) {
+        type = lowerCase.call(type);
+        if (type == "finite") {
+            return !isnan[has](+o);
+        }
+        if (type == "array") {
+            return o instanceof Array;
+        }
+        return  (type == "null" && o === null) ||
+                (type == typeof o && o !== null) ||
+                (type == "object" && o === Object(o)) ||
+                (type == "array" && Array.isArray && Array.isArray(o)) ||
+                objectToString.call(o).slice(8, -1).toLowerCase() == type;
+    };
+
+    function clone(obj) {
+        if (typeof obj == "function" || Object(obj) !== obj) {
+            return obj;
+        }
+        var res = new obj.constructor;
+        for (var key in obj) if (obj[has](key)) {
+            res[key] = clone(obj[key]);
+        }
+        return res;
+    }
+
+    /*\
+     * Raphael.angle
+     [ method ]
+     **
+     * Returns angle between two or three points
+     > Parameters
+     - x1 (number) x coord of first point
+     - y1 (number) y coord of first point
+     - x2 (number) x coord of second point
+     - y2 (number) y coord of second point
+     - x3 (number) #optional x coord of third point
+     - y3 (number) #optional y coord of third point
+     = (number) angle in degrees.
+    \*/
+    R.angle = function (x1, y1, x2, y2, x3, y3) {
+        if (x3 == null) {
+            var x = x1 - x2,
+                y = y1 - y2;
+            if (!x && !y) {
+                return 0;
+            }
+            return (180 + math.atan2(-y, -x) * 180 / PI + 360) % 360;
+        } else {
+            return R.angle(x1, y1, x3, y3) - R.angle(x2, y2, x3, y3);
+        }
+    };
+    /*\
+     * Raphael.rad
+     [ method ]
+     **
+     * Transform angle to radians
+     > Parameters
+     - deg (number) angle in degrees
+     = (number) angle in radians.
+    \*/
+    R.rad = function (deg) {
+        return deg % 360 * PI / 180;
+    };
+    /*\
+     * Raphael.deg
+     [ method ]
+     **
+     * Transform angle to degrees
+     > Parameters
+     - deg (number) angle in radians
+     = (number) angle in degrees.
+    \*/
+    R.deg = function (rad) {
+        return rad * 180 / PI % 360;
+    };
+    /*\
+     * Raphael.snapTo
+     [ method ]
+     **
+     * Snaps given value to given grid.
+     > Parameters
+     - values (array|number) given array of values or step of the grid
+     - value (number) value to adjust
+     - tolerance (number) #optional tolerance for snapping. Default is `10`.
+     = (number) adjusted value.
+    \*/
+    R.snapTo = function (values, value, tolerance) {
+        tolerance = R.is(tolerance, "finite") ? tolerance : 10;
+        if (R.is(values, array)) {
+            var i = values.length;
+            while (i--) if (abs(values[i] - value) <= tolerance) {
+                return values[i];
+            }
+        } else {
+            values = +values;
+            var rem = value % values;
+            if (rem < tolerance) {
+                return value - rem;
+            }
+            if (rem > values - tolerance) {
+                return value - rem + values;
+            }
+        }
+        return value;
+    };
+
+    /*\
+     * Raphael.createUUID
+     [ method ]
+     **
+     * Returns RFC4122, version 4 ID
+    \*/
+    var createUUID = R.createUUID = (function (uuidRegEx, uuidReplacer) {
+        return function () {
+            return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(uuidRegEx, uuidReplacer).toUpperCase();
+        };
+    })(/[xy]/g, function (c) {
+        var r = math.random() * 16 | 0,
+            v = c == "x" ? r : (r & 3 | 8);
+        return v.toString(16);
+    });
+
+    /*\
+     * Raphael.setWindow
+     [ method ]
+     **
+     * Used when you need to draw in `&lt;iframe>`. Switched window to the iframe one.
+     > Parameters
+     - newwin (window) new window object
+    \*/
+    R.setWindow = function (newwin) {
+        eve("raphael.setWindow", R, g.win, newwin);
+        g.win = newwin;
+        g.doc = g.win.document;
+        if (R._engine.initWin) {
+            R._engine.initWin(g.win);
+        }
+    };
+    var toHex = function (color) {
+        if (R.vml) {
+            // http://dean.edwards.name/weblog/2009/10/convert-any-colour-value-to-hex-in-msie/
+            var trim = /^\s+|\s+$/g;
+            var bod;
+            try {
+                var docum = new ActiveXObject("htmlfile");
+                docum.write("<body>");
+                docum.close();
+                bod = docum.body;
+            } catch(e) {
+                bod = createPopup().document.body;
+            }
+            var range = bod.createTextRange();
+            toHex = cacher(function (color) {
+                try {
+                    bod.style.color = Str(color).replace(trim, E);
+                    var value = range.queryCommandValue("ForeColor");
+                    value = ((value & 255) << 16) | (value & 65280) | ((value & 16711680) >>> 16);
+                    return "#" + ("000000" + value.toString(16)).slice(-6);
+                } catch(e) {
+                    return "none";
+                }
+            });
+        } else {
+            var i = g.doc.createElement("i");
+            i.title = "Rapha\xebl Colour Picker";
+            i.style.display = "none";
+            g.doc.body.appendChild(i);
+            toHex = cacher(function (color) {
+                i.style.color = color;
+                return g.doc.defaultView.getComputedStyle(i, E).getPropertyValue("color");
+            });
+        }
+        return toHex(color);
+    },
+    hsbtoString = function () {
+        return "hsb(" + [this.h, this.s, this.b] + ")";
+    },
+    hsltoString = function () {
+        return "hsl(" + [this.h, this.s, this.l] + ")";
+    },
+    rgbtoString = function () {
+        return this.hex;
+    },
+    prepareRGB = function (r, g, b) {
+        if (g == null && R.is(r, "object") && "r" in r && "g" in r && "b" in r) {
+            b = r.b;
+            g = r.g;
+            r = r.r;
+        }
+        if (g == null && R.is(r, string)) {
+            var clr = R.getRGB(r);
+            r = clr.r;
+            g = clr.g;
+            b = clr.b;
+        }
+        if (r > 1 || g > 1 || b > 1) {
+            r /= 255;
+            g /= 255;
+            b /= 255;
+        }
+
+        return [r, g, b];
+    },
+    packageRGB = function (r, g, b, o) {
+        r *= 255;
+        g *= 255;
+        b *= 255;
+        var rgb = {
+            r: r,
+            g: g,
+            b: b,
+            hex: R.rgb(r, g, b),
+            toString: rgbtoString
+        };
+        R.is(o, "finite") && (rgb.opacity = o);
+        return rgb;
+    };
+
+    /*\
+     * Raphael.color
+     [ method ]
+     **
+     * Parses the color string and returns object with all values for the given color.
+     > Parameters
+     - clr (string) color string in one of the supported formats (see @Raphael.getRGB)
+     = (object) Combined RGB & HSB object in format:
+     o {
+     o     r (number) red,
+     o     g (number) green,
+     o     b (number) blue,
+     o     hex (string) color in HTML/CSS format: #••••••,
+     o     error (boolean) `true` if string can’t be parsed,
+     o     h (number) hue,
+     o     s (number) saturation,
+     o     v (number) value (brightness),
+     o     l (number) lightness
+     o }
+    \*/
+    R.color = function (clr) {
+        var rgb;
+        if (R.is(clr, "object") && "h" in clr && "s" in clr && "b" in clr) {
+            rgb = R.hsb2rgb(clr);
+            clr.r = rgb.r;
+            clr.g = rgb.g;
+            clr.b = rgb.b;
+            clr.hex = rgb.hex;
+        } else if (R.is(clr, "object") && "h" in clr && "s" in clr && "l" in clr) {
+            rgb = R.hsl2rgb(clr);
+            clr.r = rgb.r;
+            clr.g = rgb.g;
+            clr.b = rgb.b;
+            clr.hex = rgb.hex;
+        } else {
+            if (R.is(clr, "string")) {
+                clr = R.getRGB(clr);
+            }
+            if (R.is(clr, "object") && "r" in clr && "g" in clr && "b" in clr) {
+                rgb = R.rgb2hsl(clr);
+                clr.h = rgb.h;
+                clr.s = rgb.s;
+                clr.l = rgb.l;
+                rgb = R.rgb2hsb(clr);
+                clr.v = rgb.b;
+            } else {
+                clr = {hex: "none"};
+                clr.r = clr.g = clr.b = clr.h = clr.s = clr.v = clr.l = -1;
+            }
+        }
+        clr.toString = rgbtoString;
+        return clr;
+    };
+    /*\
+     * Raphael.hsb2rgb
+     [ method ]
+     **
+     * Converts HSB values to RGB object.
+     > Parameters
+     - h (number) hue
+     - s (number) saturation
+     - v (number) value or brightness
+     = (object) RGB object in format:
+     o {
+     o     r (number) red,
+     o     g (number) green,
+     o     b (number) blue,
+     o     hex (string) color in HTML/CSS format: #••••••
+     o }
+    \*/
+    R.hsb2rgb = function (h, s, v, o) {
+        if (this.is(h, "object") && "h" in h && "s" in h && "b" in h) {
+            v = h.b;
+            s = h.s;
+            h = h.h;
+            o = h.o;
+        }
+        h *= 360;
+        var R, G, B, X, C;
+        h = (h % 360) / 60;
+        C = v * s;
+        X = C * (1 - abs(h % 2 - 1));
+        R = G = B = v - C;
+
+        h = ~~h;
+        R += [C, X, 0, 0, X, C][h];
+        G += [X, C, C, X, 0, 0][h];
+        B += [0, 0, X, C, C, X][h];
+        return packageRGB(R, G, B, o);
+    };
+    /*\
+     * Raphael.hsl2rgb
+     [ method ]
+     **
+     * Converts HSL values to RGB object.
+     > Parameters
+     - h (number) hue
+     - s (number) saturation
+     - l (number) luminosity
+     = (object) RGB object in format:
+     o {
+     o     r (number) red,
+     o     g (number) green,
+     o     b (number) blue,
+     o     hex (string) color in HTML/CSS format: #••••••
+     o }
+    \*/
+    R.hsl2rgb = function (h, s, l, o) {
+        if (this.is(h, "object") && "h" in h && "s" in h && "l" in h) {
+            l = h.l;
+            s = h.s;
+            h = h.h;
+        }
+        if (h > 1 || s > 1 || l > 1) {
+            h /= 360;
+            s /= 100;
+            l /= 100;
+        }
+        h *= 360;
+        var R, G, B, X, C;
+        h = (h % 360) / 60;
+        C = 2 * s * (l < .5 ? l : 1 - l);
+        X = C * (1 - abs(h % 2 - 1));
+        R = G = B = l - C / 2;
+
+        h = ~~h;
+        R += [C, X, 0, 0, X, C][h];
+        G += [X, C, C, X, 0, 0][h];
+        B += [0, 0, X, C, C, X][h];
+        return packageRGB(R, G, B, o);
+    };
+    /*\
+     * Raphael.rgb2hsb
+     [ method ]
+     **
+     * Converts RGB values to HSB object.
+     > Parameters
+     - r (number) red
+     - g (number) green
+     - b (number) blue
+     = (object) HSB object in format:
+     o {
+     o     h (number) hue
+     o     s (number) saturation
+     o     b (number) brightness
+     o }
+    \*/
+    R.rgb2hsb = function (r, g, b) {
+        b = prepareRGB(r, g, b);
+        r = b[0];
+        g = b[1];
+        b = b[2];
+
+        var H, S, V, C;
+        V = mmax(r, g, b);
+        C = V - mmin(r, g, b);
+        H = (C == 0 ? null :
+             V == r ? (g - b) / C :
+             V == g ? (b - r) / C + 2 :
+                      (r - g) / C + 4
+            );
+        H = ((H + 360) % 6) * 60 / 360;
+        S = C == 0 ? 0 : C / V;
+        return {h: H, s: S, b: V, toString: hsbtoString};
+    };
+    /*\
+     * Raphael.rgb2hsl
+     [ method ]
+     **
+     * Converts RGB values to HSL object.
+     > Parameters
+     - r (number) red
+     - g (number) green
+     - b (number) blue
+     = (object) HSL object in format:
+     o {
+     o     h (number) hue
+     o     s (number) saturation
+     o     l (number) luminosity
+     o }
+    \*/
+    R.rgb2hsl = function (r, g, b) {
+        b = prepareRGB(r, g, b);
+        r = b[0];
+        g = b[1];
+        b = b[2];
+
+        var H, S, L, M, m, C;
+        M = mmax(r, g, b);
+        m = mmin(r, g, b);
+        C = M - m;
+        H = (C == 0 ? null :
+             M == r ? (g - b) / C :
+             M == g ? (b - r) / C + 2 :
+                      (r - g) / C + 4);
+        H = ((H + 360) % 6) * 60 / 360;
+        L = (M + m) / 2;
+        S = (C == 0 ? 0 :
+             L < .5 ? C / (2 * L) :
+                      C / (2 - 2 * L));
+        return {h: H, s: S, l: L, toString: hsltoString};
+    };
+    R._path2string = function () {
+        return this.join(",").replace(p2s, "$1");
+    };
+    function repush(array, item) {
+        for (var i = 0, ii = array.length; i < ii; i++) if (array[i] === item) {
+            return array.push(array.splice(i, 1)[0]);
+        }
+    }
+    function cacher(f, scope, postprocessor) {
+        function newf() {
+            var arg = Array.prototype.slice.call(arguments, 0),
+                args = arg.join("\u2400"),
+                cache = newf.cache = newf.cache || {},
+                count = newf.count = newf.count || [];
+            if (cache[has](args)) {
+                repush(count, args);
+                return postprocessor ? postprocessor(cache[args]) : cache[args];
+            }
+            count.length >= 1e3 && delete cache[count.shift()];
+            count.push(args);
+            cache[args] = f[apply](scope, arg);
+            return postprocessor ? postprocessor(cache[args]) : cache[args];
+        }
+        return newf;
+    }
+
+    var preload = R._preload = function (src, f) {
+        var img = g.doc.createElement("img");
+        img.style.cssText = "position:absolute;left:-9999em;top:-9999em";
+        img.onload = function () {
+            f.call(this);
+            this.onload = null;
+            g.doc.body.removeChild(this);
+        };
+        img.onerror = function () {
+            g.doc.body.removeChild(this);
+        };
+        g.doc.body.appendChild(img);
+        img.src = src;
+    };
+
+    function clrToString() {
+        return this.hex;
+    }
+
+    /*\
+     * Raphael.getRGB
+     [ method ]
+     **
+     * Parses colour string as RGB object
+     > Parameters
+     - colour (string) colour string in one of formats:
+     # <ul>
+     #     <li>Colour name (“<code>red</code>”, “<code>green</code>”, “<code>cornflowerblue</code>”, etc)</li>
+     #     <li>#••• — shortened HTML colour: (“<code>#000</code>”, “<code>#fc0</code>”, etc)</li>
+     #     <li>#•••••• — full length HTML colour: (“<code>#000000</code>”, “<code>#bd2300</code>”)</li>
+     #     <li>rgb(•••, •••, •••) — red, green and blue channels’ values: (“<code>rgb(200,&nbsp;100,&nbsp;0)</code>”)</li>
+     #     <li>rgb(•••%, •••%, •••%) — same as above, but in %: (“<code>rgb(100%,&nbsp;175%,&nbsp;0%)</code>”)</li>
+     #     <li>hsb(•••, •••, •••) — hue, saturation and brightness values: (“<code>hsb(0.5,&nbsp;0.25,&nbsp;1)</code>”)</li>
+     #     <li>hsb(•••%, •••%, •••%) — same as above, but in %</li>
+     #     <li>hsl(•••, •••, •••) — same as hsb</li>
+     #     <li>hsl(•••%, •••%, •••%) — same as hsb</li>
+     # </ul>
+     = (object) RGB object in format:
+     o {
+     o     r (number) red,
+     o     g (number) green,
+     o     b (number) blue
+     o     hex (string) color in HTML/CSS format: #••••••,
+     o     error (boolean) true if string can’t be parsed
+     o }
+    \*/
+    R.getRGB = cacher(function (colour) {
+        if (!colour || !!((colour = Str(colour)).indexOf("-") + 1)) {
+            return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: clrToString};
+        }
+        if (colour == "none") {
+            return {r: -1, g: -1, b: -1, hex: "none", toString: clrToString};
+        }
+        !(hsrg[has](colour.toLowerCase().substring(0, 2)) || colour.charAt() == "#") && (colour = toHex(colour));
+        var res,
+            red,
+            green,
+            blue,
+            opacity,
+            t,
+            values,
+            rgb = colour.match(colourRegExp);
+        if (rgb) {
+            if (rgb[2]) {
+                blue = toInt(rgb[2].substring(5), 16);
+                green = toInt(rgb[2].substring(3, 5), 16);
+                red = toInt(rgb[2].substring(1, 3), 16);
+            }
+            if (rgb[3]) {
+                blue = toInt((t = rgb[3].charAt(3)) + t, 16);
+                green = toInt((t = rgb[3].charAt(2)) + t, 16);
+                red = toInt((t = rgb[3].charAt(1)) + t, 16);
+            }
+            if (rgb[4]) {
+                values = rgb[4][split](commaSpaces);
+                red = toFloat(values[0]);
+                values[0].slice(-1) == "%" && (red *= 2.55);
+                green = toFloat(values[1]);
+                values[1].slice(-1) == "%" && (green *= 2.55);
+                blue = toFloat(values[2]);
+                values[2].slice(-1) == "%" && (blue *= 2.55);
+                rgb[1].toLowerCase().slice(0, 4) == "rgba" && (opacity = toFloat(values[3]));
+                values[3] && values[3].slice(-1) == "%" && (opacity /= 100);
+            }
+            if (rgb[5]) {
+                values = rgb[5][split](commaSpaces);
+                red = toFloat(values[0]);
+                values[0].slice(-1) == "%" && (red *= 2.55);
+                green = toFloat(values[1]);
+                values[1].slice(-1) == "%" && (green *= 2.55);
+                blue = toFloat(values[2]);
+                values[2].slice(-1) == "%" && (blue *= 2.55);
+                (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360);
+                rgb[1].toLowerCase().slice(0, 4) == "hsba" && (opacity = toFloat(values[3]));
+                values[3] && values[3].slice(-1) == "%" && (opacity /= 100);
+                return R.hsb2rgb(red, green, blue, opacity);
+            }
+            if (rgb[6]) {
+                values = rgb[6][split](commaSpaces);
+                red = toFloat(values[0]);
+                values[0].slice(-1) == "%" && (red *= 2.55);
+                green = toFloat(values[1]);
+                values[1].slice(-1) == "%" && (green *= 2.55);
+                blue = toFloat(values[2]);
+                values[2].slice(-1) == "%" && (blue *= 2.55);
+                (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360);
+                rgb[1].toLowerCase().slice(0, 4) == "hsla" && (opacity = toFloat(values[3]));
+                values[3] && values[3].slice(-1) == "%" && (opacity /= 100);
+                return R.hsl2rgb(red, green, blue, opacity);
+            }
+            rgb = {r: red, g: green, b: blue, toString: clrToString};
+            rgb.hex = "#" + (16777216 | blue | (green << 8) | (red << 16)).toString(16).slice(1);
+            R.is(opacity, "finite") && (rgb.opacity = opacity);
+            return rgb;
+        }
+        return {r: -1, g: -1, b: -1, hex: "none", error: 1, toString: clrToString};
+    }, R);
+    /*\
+     * Raphael.hsb
+     [ method ]
+     **
+     * Converts HSB values to hex representation of the colour.
+     > Parameters
+     - h (number) hue
+     - s (number) saturation
+     - b (number) value or brightness
+     = (string) hex representation of the colour.
+    \*/
+    R.hsb = cacher(function (h, s, b) {
+        return R.hsb2rgb(h, s, b).hex;
+    });
+    /*\
+     * Raphael.hsl
+     [ method ]
+     **
+     * Converts HSL values to hex representation of the colour.
+     > Parameters
+     - h (number) hue
+     - s (number) saturation
+     - l (number) luminosity
+     = (string) hex representation of the colour.
+    \*/
+    R.hsl = cacher(function (h, s, l) {
+        return R.hsl2rgb(h, s, l).hex;
+    });
+    /*\
+     * Raphael.rgb
+     [ method ]
+     **
+     * Converts RGB values to hex representation of the colour.
+     > Parameters
+     - r (number) red
+     - g (number) green
+     - b (number) blue
+     = (string) hex representation of the colour.
+    \*/
+    R.rgb = cacher(function (r, g, b) {
+        return "#" + (16777216 | b | (g << 8) | (r << 16)).toString(16).slice(1);
+    });
+    /*\
+     * Raphael.getColor
+     [ method ]
+     **
+     * On each call returns next colour in the spectrum. To reset it back to red call @Raphael.getColor.reset
+     > Parameters
+     - value (number) #optional brightness, default is `0.75`
+     = (string) hex representation of the colour.
+    \*/
+    R.getColor = function (value) {
+        var start = this.getColor.start = this.getColor.start || {h: 0, s: 1, b: value || .75},
+            rgb = this.hsb2rgb(start.h, start.s, start.b);
+        start.h += .075;
+        if (start.h > 1) {
+            start.h = 0;
+            start.s -= .2;
+            start.s <= 0 && (this.getColor.start = {h: 0, s: 1, b: start.b});
+        }
+        return rgb.hex;
+    };
+    /*\
+     * Raphael.getColor.reset
+     [ method ]
+     **
+     * Resets spectrum position for @Raphael.getColor back to red.
+    \*/
+    R.getColor.reset = function () {
+        delete this.start;
+    };
+
+    // http://schepers.cc/getting-to-the-point
+    function catmullRom2bezier(crp, z) {
+        var d = [];
+        for (var i = 0, iLen = crp.length; iLen - 2 * !z > i; i += 2) {
+            var p = [
+                        {x: +crp[i - 2], y: +crp[i - 1]},
+                        {x: +crp[i],     y: +crp[i + 1]},
+                        {x: +crp[i + 2], y: +crp[i + 3]},
+                        {x: +crp[i + 4], y: +crp[i + 5]}
+                    ];
+            if (z) {
+                if (!i) {
+                    p[0] = {x: +crp[iLen - 2], y: +crp[iLen - 1]};
+                } else if (iLen - 4 == i) {
+                    p[3] = {x: +crp[0], y: +crp[1]};
+                } else if (iLen - 2 == i) {
+                    p[2] = {x: +crp[0], y: +crp[1]};
+                    p[3] = {x: +crp[2], y: +crp[3]};
+                }
+            } else {
+                if (iLen - 4 == i) {
+                    p[3] = p[2];
+                } else if (!i) {
+                    p[0] = {x: +crp[i], y: +crp[i + 1]};
+                }
+            }
+            d.push(["C",
+                  (-p[0].x + 6 * p[1].x + p[2].x) / 6,
+                  (-p[0].y + 6 * p[1].y + p[2].y) / 6,
+                  (p[1].x + 6 * p[2].x - p[3].x) / 6,
+                  (p[1].y + 6*p[2].y - p[3].y) / 6,
+                  p[2].x,
+                  p[2].y
+            ]);
+        }
+
+        return d;
+    }
+    /*\
+     * Raphael.parsePathString
+     [ method ]
+     **
+     * Utility method
+     **
+     * Parses given path string into an array of arrays of path segments.
+     > Parameters
+     - pathString (string|array) path string or array of segments (in the last case it will be returned straight away)
+     = (array) array of segments.
+    \*/
+    R.parsePathString = function (pathString) {
+        if (!pathString) {
+            return null;
+        }
+        var pth = paths(pathString);
+        if (pth.arr) {
+            return pathClone(pth.arr);
+        }
+
+        var paramCounts = {a: 7, c: 6, h: 1, l: 2, m: 2, r: 4, q: 4, s: 4, t: 2, v: 1, z: 0},
+            data = [];
+        if (R.is(pathString, array) && R.is(pathString[0], array)) { // rough assumption
+            data = pathClone(pathString);
+        }
+        if (!data.length) {
+            Str(pathString).replace(pathCommand, function (a, b, c) {
+                var params = [],
+                    name = b.toLowerCase();
+                c.replace(pathValues, function (a, b) {
+                    b && params.push(+b);
+                });
+                if (name == "m" && params.length > 2) {
+                    data.push([b][concat](params.splice(0, 2)));
+                    name = "l";
+                    b = b == "m" ? "l" : "L";
+                }
+                if (name == "r") {
+                    data.push([b][concat](params));
+                } else while (params.length >= paramCounts[name]) {
+                    data.push([b][concat](params.splice(0, paramCounts[name])));
+                    if (!paramCounts[name]) {
+                        break;
+                    }
+                }
+            });
+        }
+        data.toString = R._path2string;
+        pth.arr = pathClone(data);
+        return data;
+    };
+    /*\
+     * Raphael.parseTransformString
+     [ method ]
+     **
+     * Utility method
+     **
+     * Parses given path string into an array of transformations.
+     > Parameters
+     - TString (string|array) transform string or array of transformations (in the last case it will be returned straight away)
+     = (array) array of transformations.
+    \*/
+    R.parseTransformString = cacher(function (TString) {
+        if (!TString) {
+            return null;
+        }
+        var paramCounts = {r: 3, s: 4, t: 2, m: 6},
+            data = [];
+        if (R.is(TString, array) && R.is(TString[0], array)) { // rough assumption
+            data = pathClone(TString);
+        }
+        if (!data.length) {
+            Str(TString).replace(tCommand, function (a, b, c) {
+                var params = [],
+                    name = lowerCase.call(b);
+                c.replace(pathValues, function (a, b) {
+                    b && params.push(+b);
+                });
+                data.push([b][concat](params));
+            });
+        }
+        data.toString = R._path2string;
+        return data;
+    });
+    // PATHS
+    var paths = function (ps) {
+        var p = paths.ps = paths.ps || {};
+        if (p[ps]) {
+            p[ps].sleep = 100;
+        } else {
+            p[ps] = {
+                sleep: 100
+            };
+        }
+        setTimeout(function () {
+            for (var key in p) if (p[has](key) && key != ps) {
+                p[key].sleep--;
+                !p[key].sleep && delete p[key];
+            }
+        });
+        return p[ps];
+    };
+    /*\
+     * Raphael.findDotsAtSegment
+     [ method ]
+     **
+     * Utility method
+     **
+     * Find dot coordinates on the given cubic bezier curve at the given t.
+     > Parameters
+     - p1x (number) x of the first point of the curve
+     - p1y (number) y of the first point of the curve
+     - c1x (number) x of the first anchor of the curve
+     - c1y (number) y of the first anchor of the curve
+     - c2x (number) x of the second anchor of the curve
+     - c2y (number) y of the second anchor of the curve
+     - p2x (number) x of the second point of the curve
+     - p2y (number) y of the second point of the curve
+     - t (number) position on the curve (0..1)
+     = (object) point information in format:
+     o {
+     o     x: (number) x coordinate of the point
+     o     y: (number) y coordinate of the point
+     o     m: {
+     o         x: (number) x coordinate of the left anchor
+     o         y: (number) y coordinate of the left anchor
+     o     }
+     o     n: {
+     o         x: (number) x coordinate of the right anchor
+     o         y: (number) y coordinate of the right anchor
+     o     }
+     o     start: {
+     o         x: (number) x coordinate of the start of the curve
+     o         y: (number) y coordinate of the start of the curve
+     o     }
+     o     end: {
+     o         x: (number) x coordinate of the end of the curve
+     o         y: (number) y coordinate of the end of the curve
+     o     }
+     o     alpha: (number) angle of the curve derivative at the point
+     o }
+    \*/
+    R.findDotsAtSegment = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
+        var t1 = 1 - t,
+            t13 = pow(t1, 3),
+            t12 = pow(t1, 2),
+            t2 = t * t,
+            t3 = t2 * t,
+            x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x,
+            y = t13 * p1y + t12 * 3 * t * c1y + t1 * 3 * t * t * c2y + t3 * p2y,
+            mx = p1x + 2 * t * (c1x - p1x) + t2 * (c2x - 2 * c1x + p1x),
+            my = p1y + 2 * t * (c1y - p1y) + t2 * (c2y - 2 * c1y + p1y),
+            nx = c1x + 2 * t * (c2x - c1x) + t2 * (p2x - 2 * c2x + c1x),
+            ny = c1y + 2 * t * (c2y - c1y) + t2 * (p2y - 2 * c2y + c1y),
+            ax = t1 * p1x + t * c1x,
+            ay = t1 * p1y + t * c1y,
+            cx = t1 * c2x + t * p2x,
+            cy = t1 * c2y + t * p2y,
+            alpha = (90 - math.atan2(mx - nx, my - ny) * 180 / PI);
+        (mx > nx || my < ny) && (alpha += 180);
+        return {
+            x: x,
+            y: y,
+            m: {x: mx, y: my},
+            n: {x: nx, y: ny},
+            start: {x: ax, y: ay},
+            end: {x: cx, y: cy},
+            alpha: alpha
+        };
+    };
+    /*\
+     * Raphael.bezierBBox
+     [ method ]
+     **
+     * Utility method
+     **
+     * Return bounding box of a given cubic bezier curve
+     > Parameters
+     - p1x (number) x of the first point of the curve
+     - p1y (number) y of the first point of the curve
+     - c1x (number) x of the first anchor of the curve
+     - c1y (number) y of the first anchor of the curve
+     - c2x (number) x of the second anchor of the curve
+     - c2y (number) y of the second anchor of the curve
+     - p2x (number) x of the second point of the curve
+     - p2y (number) y of the second point of the curve
+     * or
+     - bez (array) array of six points for bezier curve
+     = (object) point information in format:
+     o {
+     o     min: {
+     o         x: (number) x coordinate of the left point
+     o         y: (number) y coordinate of the top point
+     o     }
+     o     max: {
+     o         x: (number) x coordinate of the right point
+     o         y: (number) y coordinate of the bottom point
+     o     }
+     o }
+    \*/
+    R.bezierBBox = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
+        if (!R.is(p1x, "array")) {
+            p1x = [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y];
+        }
+        var bbox = curveDim.apply(null, p1x);
+        return {
+            x: bbox.min.x,
+            y: bbox.min.y,
+            x2: bbox.max.x,
+            y2: bbox.max.y,
+            width: bbox.max.x - bbox.min.x,
+            height: bbox.max.y - bbox.min.y
+        };
+    };
+    /*\
+     * Raphael.isPointInsideBBox
+     [ method ]
+     **
+     * Utility method
+     **
+     * Returns `true` if given point is inside bounding boxes.
+     > Parameters
+     - bbox (string) bounding box
+     - x (string) x coordinate of the point
+     - y (string) y coordinate of the point
+     = (boolean) `true` if point inside
+    \*/
+    R.isPointInsideBBox = function (bbox, x, y) {
+        return x >= bbox.x && x <= bbox.x2 && y >= bbox.y && y <= bbox.y2;
+    };
+    /*\
+     * Raphael.isBBoxIntersect
+     [ method ]
+     **
+     * Utility method
+     **
+     * Returns `true` if two bounding boxes intersect
+     > Parameters
+     - bbox1 (string) first bounding box
+     - bbox2 (string) second bounding box
+     = (boolean) `true` if they intersect
+    \*/
+    R.isBBoxIntersect = function (bbox1, bbox2) {
+        var i = R.isPointInsideBBox;
+        return i(bbox2, bbox1.x, bbox1.y)
+            || i(bbox2, bbox1.x2, bbox1.y)
+            || i(bbox2, bbox1.x, bbox1.y2)
+            || i(bbox2, bbox1.x2, bbox1.y2)
+            || i(bbox1, bbox2.x, bbox2.y)
+            || i(bbox1, bbox2.x2, bbox2.y)
+            || i(bbox1, bbox2.x, bbox2.y2)
+            || i(bbox1, bbox2.x2, bbox2.y2)
+            || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x)
+            && (bbox1.y < bbox2.y2 && bbox1.y > bbox2.y || bbox2.y < bbox1.y2 && bbox2.y > bbox1.y);
+    };
+    function base3(t, p1, p2, p3, p4) {
+        var t1 = -3 * p1 + 9 * p2 - 9 * p3 + 3 * p4,
+            t2 = t * t1 + 6 * p1 - 12 * p2 + 6 * p3;
+        return t * t2 - 3 * p1 + 3 * p2;
+    }
+    function bezlen(x1, y1, x2, y2, x3, y3, x4, y4, z) {
+        if (z == null) {
+            z = 1;
+        }
+        z = z > 1 ? 1 : z < 0 ? 0 : z;
+        var z2 = z / 2,
+            n = 12,
+            Tvalues = [-0.1252,0.1252,-0.3678,0.3678,-0.5873,0.5873,-0.7699,0.7699,-0.9041,0.9041,-0.9816,0.9816],
+            Cvalues = [0.2491,0.2491,0.2335,0.2335,0.2032,0.2032,0.1601,0.1601,0.1069,0.1069,0.0472,0.0472],
+            sum = 0;
+        for (var i = 0; i < n; i++) {
+            var ct = z2 * Tvalues[i] + z2,
+                xbase = base3(ct, x1, x2, x3, x4),
+                ybase = base3(ct, y1, y2, y3, y4),
+                comb = xbase * xbase + ybase * ybase;
+            sum += Cvalues[i] * math.sqrt(comb);
+        }
+        return z2 * sum;
+    }
+    function getTatLen(x1, y1, x2, y2, x3, y3, x4, y4, ll) {
+        if (ll < 0 || bezlen(x1, y1, x2, y2, x3, y3, x4, y4) < ll) {
+            return;
+        }
+        var t = 1,
+            step = t / 2,
+            t2 = t - step,
+            l,
+            e = .01;
+        l = bezlen(x1, y1, x2, y2, x3, y3, x4, y4, t2);
+        while (abs(l - ll) > e) {
+            step /= 2;
+            t2 += (l < ll ? 1 : -1) * step;
+            l = bezlen(x1, y1, x2, y2, x3, y3, x4, y4, t2);
+        }
+        return t2;
+    }
+    function intersect(x1, y1, x2, y2, x3, y3, x4, y4) {
+        if (
+            mmax(x1, x2) < mmin(x3, x4) ||
+            mmin(x1, x2) > mmax(x3, x4) ||
+            mmax(y1, y2) < mmin(y3, y4) ||
+            mmin(y1, y2) > mmax(y3, y4)
+        ) {
+            return;
+        }
+        var nx = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4),
+            ny = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4),
+            denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+
+        if (!denominator) {
+            return;
+        }
+        var px = nx / denominator,
+            py = ny / denominator,
+            px2 = +px.toFixed(2),
+            py2 = +py.toFixed(2);
+        if (
+            px2 < +mmin(x1, x2).toFixed(2) ||
+            px2 > +mmax(x1, x2).toFixed(2) ||
+            px2 < +mmin(x3, x4).toFixed(2) ||
+            px2 > +mmax(x3, x4).toFixed(2) ||
+            py2 < +mmin(y1, y2).toFixed(2) ||
+            py2 > +mmax(y1, y2).toFixed(2) ||
+            py2 < +mmin(y3, y4).toFixed(2) ||
+            py2 > +mmax(y3, y4).toFixed(2)
+        ) {
+            return;
+        }
+        return {x: px, y: py};
+    }
+    function inter(bez1, bez2) {
+        return interHelper(bez1, bez2);
+    }
+    function interCount(bez1, bez2) {
+        return interHelper(bez1, bez2, 1);
+    }
+    function interHelper(bez1, bez2, justCount) {
+        var bbox1 = R.bezierBBox(bez1),
+            bbox2 = R.bezierBBox(bez2);
+        if (!R.isBBoxIntersect(bbox1, bbox2)) {
+            return justCount ? 0 : [];
+        }
+        var l1 = bezlen.apply(0, bez1),
+            l2 = bezlen.apply(0, bez2),
+            n1 = mmax(~~(l1 / 5), 1),
+            n2 = mmax(~~(l2 / 5), 1),
+            dots1 = [],
+            dots2 = [],
+            xy = {},
+            res = justCount ? 0 : [];
+        for (var i = 0; i < n1 + 1; i++) {
+            var p = R.findDotsAtSegment.apply(R, bez1.concat(i / n1));
+            dots1.push({x: p.x, y: p.y, t: i / n1});
+        }
+        for (i = 0; i < n2 + 1; i++) {
+            p = R.findDotsAtSegment.apply(R, bez2.concat(i / n2));
+            dots2.push({x: p.x, y: p.y, t: i / n2});
+        }
+        for (i = 0; i < n1; i++) {
+            for (var j = 0; j < n2; j++) {
+                var di = dots1[i],
+                    di1 = dots1[i + 1],
+                    dj = dots2[j],
+                    dj1 = dots2[j + 1],
+                    ci = abs(di1.x - di.x) < .001 ? "y" : "x",
+                    cj = abs(dj1.x - dj.x) < .001 ? "y" : "x",
+                    is = intersect(di.x, di.y, di1.x, di1.y, dj.x, dj.y, dj1.x, dj1.y);
+                if (is) {
+                    if (xy[is.x.toFixed(4)] == is.y.toFixed(4)) {
+                        continue;
+                    }
+                    xy[is.x.toFixed(4)] = is.y.toFixed(4);
+                    var t1 = di.t + abs((is[ci] - di[ci]) / (di1[ci] - di[ci])) * (di1.t - di.t),
+                        t2 = dj.t + abs((is[cj] - dj[cj]) / (dj1[cj] - dj[cj])) * (dj1.t - dj.t);
+                    if (t1 >= 0 && t1 <= 1.001 && t2 >= 0 && t2 <= 1.001) {
+                        if (justCount) {
+                            res++;
+                        } else {
+                            res.push({
+                                x: is.x,
+                                y: is.y,
+                                t1: mmin(t1, 1),
+                                t2: mmin(t2, 1)
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return res;
+    }
+    /*\
+     * Raphael.pathIntersection
+     [ method ]
+     **
+     * Utility method
+     **
+     * Finds intersections of two paths
+     > Parameters
+     - path1 (string) path string
+     - path2 (string) path string
+     = (array) dots of intersection
+     o [
+     o     {
+     o         x: (number) x coordinate of the point
+     o         y: (number) y coordinate of the point
+     o         t1: (number) t value for segment of path1
+     o         t2: (number) t value for segment of path2
+     o         segment1: (number) order number for segment of path1
+     o         segment2: (number) order number for segment of path2
+     o         bez1: (array) eight coordinates representing beziér curve for the segment of path1
+     o         bez2: (array) eight coordinates representing beziér curve for the segment of path2
+     o     }
+     o ]
+    \*/
+    R.pathIntersection = function (path1, path2) {
+        return interPathHelper(path1, path2);
+    };
+    R.pathIntersectionNumber = function (path1, path2) {
+        return interPathHelper(path1, path2, 1);
+    };
+    function interPathHelper(path1, path2, justCount) {
+        path1 = R._path2curve(path1);
+        path2 = R._path2curve(path2);
+        var x1, y1, x2, y2, x1m, y1m, x2m, y2m, bez1, bez2,
+            res = justCount ? 0 : [];
+        for (var i = 0, ii = path1.length; i < ii; i++) {
+            var pi = path1[i];
+            if (pi[0] == "M") {
+                x1 = x1m = pi[1];
+                y1 = y1m = pi[2];
+            } else {
+                if (pi[0] == "C") {
+                    bez1 = [x1, y1].concat(pi.slice(1));
+                    x1 = bez1[6];
+                    y1 = bez1[7];
+                } else {
+                    bez1 = [x1, y1, x1, y1, x1m, y1m, x1m, y1m];
+                    x1 = x1m;
+                    y1 = y1m;
+                }
+                for (var j = 0, jj = path2.length; j < jj; j++) {
+                    var pj = path2[j];
+                    if (pj[0] == "M") {
+                        x2 = x2m = pj[1];
+                        y2 = y2m = pj[2];
+                    } else {
+                        if (pj[0] == "C") {
+                            bez2 = [x2, y2].concat(pj.slice(1));
+                            x2 = bez2[6];
+                            y2 = bez2[7];
+                        } else {
+                            bez2 = [x2, y2, x2, y2, x2m, y2m, x2m, y2m];
+                            x2 = x2m;
+                            y2 = y2m;
+                        }
+                        var intr = interHelper(bez1, bez2, justCount);
+                        if (justCount) {
+                            res += intr;
+                        } else {
+                            for (var k = 0, kk = intr.length; k < kk; k++) {
+                                intr[k].segment1 = i;
+                                intr[k].segment2 = j;
+                                intr[k].bez1 = bez1;
+                                intr[k].bez2 = bez2;
+                            }
+                            res = res.concat(intr);
+                        }
+                    }
+                }
+            }
+        }
+        return res;
+    }
+    /*\
+     * Raphael.isPointInsidePath
+     [ method ]
+     **
+     * Utility method
+     **
+     * Returns `true` if given point is inside a given closed path.
+     > Parameters
+     - path (string) path string
+     - x (number) x of the point
+     - y (number) y of the point
+     = (boolean) true, if point is inside the path
+    \*/
+    R.isPointInsidePath = function (path, x, y) {
+        var bbox = R.pathBBox(path);
+        return R.isPointInsideBBox(bbox, x, y) &&
+               interPathHelper(path, [["M", x, y], ["H", bbox.x2 + 10]], 1) % 2 == 1;
+    };
+    R._removedFactory = function (methodname) {
+        return function () {
+            eve("raphael.log", null, "Rapha\xebl: you are calling to method \u201c" + methodname + "\u201d of removed object", methodname);
+        };
+    };
+    /*\
+     * Raphael.pathBBox
+     [ method ]
+     **
+     * Utility method
+     **
+     * Return bounding box of a given path
+     > Parameters
+     - path (string) path string
+     = (object) bounding box
+     o {
+     o     x: (number) x coordinate of the left top point of the box
+     o     y: (number) y coordinate of the left top point of the box
+     o     x2: (number) x coordinate of the right bottom point of the box
+     o     y2: (number) y coordinate of the right bottom point of the box
+     o     width: (number) width of the box
+     o     height: (number) height of the box
+     o     cx: (number) x coordinate of the center of the box
+     o     cy: (number) y coordinate of the center of the box
+     o }
+    \*/
+    var pathDimensions = R.pathBBox = function (path) {
+        var pth = paths(path);
+        if (pth.bbox) {
+            return clone(pth.bbox);
+        }
+        if (!path) {
+            return {x: 0, y: 0, width: 0, height: 0, x2: 0, y2: 0};
+        }
+        path = path2curve(path);
+        var x = 0,
+            y = 0,
+            X = [],
+            Y = [],
+            p;
+        for (var i = 0, ii = path.length; i < ii; i++) {
+            p = path[i];
+            if (p[0] == "M") {
+                x = p[1];
+                y = p[2];
+                X.push(x);
+                Y.push(y);
+            } else {
+                var dim = curveDim(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
+                X = X[concat](dim.min.x, dim.max.x);
+                Y = Y[concat](dim.min.y, dim.max.y);
+                x = p[5];
+                y = p[6];
+            }
+        }
+        var xmin = mmin[apply](0, X),
+            ymin = mmin[apply](0, Y),
+            xmax = mmax[apply](0, X),
+            ymax = mmax[apply](0, Y),
+            width = xmax - xmin,
+            height = ymax - ymin,
+                bb = {
+                x: xmin,
+                y: ymin,
+                x2: xmax,
+                y2: ymax,
+                width: width,
+                height: height,
+                cx: xmin + width / 2,
+                cy: ymin + height / 2
+            };
+        pth.bbox = clone(bb);
+        return bb;
+    },
+        pathClone = function (pathArray) {
+            var res = clone(pathArray);
+            res.toString = R._path2string;
+            return res;
+        },
+        pathToRelative = R._pathToRelative = function (pathArray) {
+            var pth = paths(pathArray);
+            if (pth.rel) {
+                return pathClone(pth.rel);
+            }
+            if (!R.is(pathArray, array) || !R.is(pathArray && pathArray[0], array)) { // rough assumption
+                pathArray = R.parsePathString(pathArray);
+            }
+            var res = [],
+                x = 0,
+                y = 0,
+                mx = 0,
+                my = 0,
+                start = 0;
+            if (pathArray[0][0] == "M") {
+                x = pathArray[0][1];
+                y = pathArray[0][2];
+                mx = x;
+                my = y;
+                start++;
+                res.push(["M", x, y]);
+            }
+            for (var i = start, ii = pathArray.length; i < ii; i++) {
+                var r = res[i] = [],
+                    pa = pathArray[i];
+                if (pa[0] != lowerCase.call(pa[0])) {
+                    r[0] = lowerCase.call(pa[0]);
+                    switch (r[0]) {
+                        case "a":
+                            r[1] = pa[1];
+                            r[2] = pa[2];
+                            r[3] = pa[3];
+                            r[4] = pa[4];
+                            r[5] = pa[5];
+                            r[6] = +(pa[6] - x).toFixed(3);
+                            r[7] = +(pa[7] - y).toFixed(3);
+                            break;
+                        case "v":
+                            r[1] = +(pa[1] - y).toFixed(3);
+                            break;
+                        case "m":
+                            mx = pa[1];
+                            my = pa[2];
+                        default:
+                            for (var j = 1, jj = pa.length; j < jj; j++) {
+                                r[j] = +(pa[j] - ((j % 2) ? x : y)).toFixed(3);
+                            }
+                    }
+                } else {
+                    r = res[i] = [];
+                    if (pa[0] == "m") {
+                        mx = pa[1] + x;
+                        my = pa[2] + y;
+                    }
+                    for (var k = 0, kk = pa.length; k < kk; k++) {
+                        res[i][k] = pa[k];
+                    }
+                }
+                var len = res[i].length;
+                switch (res[i][0]) {
+                    case "z":
+                        x = mx;
+                        y = my;
+                        break;
+                    case "h":
+                        x += +res[i][len - 1];
+                        break;
+                    case "v":
+                        y += +res[i][len - 1];
+                        break;
+                    default:
+                        x += +res[i][len - 2];
+                        y += +res[i][len - 1];
+                }
+            }
+            res.toString = R._path2string;
+            pth.rel = pathClone(res);
+            return res;
+        },
+        pathToAbsolute = R._pathToAbsolute = function (pathArray) {
+            var pth = paths(pathArray);
+            if (pth.abs) {
+                return pathClone(pth.abs);
+            }
+            if (!R.is(pathArray, array) || !R.is(pathArray && pathArray[0], array)) { // rough assumption
+                pathArray = R.parsePathString(pathArray);
+            }
+            if (!pathArray || !pathArray.length) {
+                return [["M", 0, 0]];
+            }
+            var res = [],
+                x = 0,
+                y = 0,
+                mx = 0,
+                my = 0,
+                start = 0;
+            if (pathArray[0][0] == "M") {
+                x = +pathArray[0][1];
+                y = +pathArray[0][2];
+                mx = x;
+                my = y;
+                start++;
+                res[0] = ["M", x, y];
+            }
+            var crz = pathArray.length == 3 && pathArray[0][0] == "M" && pathArray[1][0].toUpperCase() == "R" && pathArray[2][0].toUpperCase() == "Z";
+            for (var r, pa, i = start, ii = pathArray.length; i < ii; i++) {
+                res.push(r = []);
+                pa = pathArray[i];
+                if (pa[0] != upperCase.call(pa[0])) {
+                    r[0] = upperCase.call(pa[0]);
+                    switch (r[0]) {
+                        case "A":
+                            r[1] = pa[1];
+                            r[2] = pa[2];
+                            r[3] = pa[3];
+                            r[4] = pa[4];
+                            r[5] = pa[5];
+                            r[6] = +(pa[6] + x);
+                            r[7] = +(pa[7] + y);
+                            break;
+                        case "V":
+                            r[1] = +pa[1] + y;
+                            break;
+                        case "H":
+                            r[1] = +pa[1] + x;
+                            break;
+                        case "R":
+                            var dots = [x, y][concat](pa.slice(1));
+                            for (var j = 2, jj = dots.length; j < jj; j++) {
+                                dots[j] = +dots[j] + x;
+                                dots[++j] = +dots[j] + y;
+                            }
+                            res.pop();
+                            res = res[concat](catmullRom2bezier(dots, crz));
+                            break;
+                        case "M":
+                            mx = +pa[1] + x;
+                            my = +pa[2] + y;
+                        default:
+                            for (j = 1, jj = pa.length; j < jj; j++) {
+                                r[j] = +pa[j] + ((j % 2) ? x : y);
+                            }
+                    }
+                } else if (pa[0] == "R") {
+                    dots = [x, y][concat](pa.slice(1));
+                    res.pop();
+                    res = res[concat](catmullRom2bezier(dots, crz));
+                    r = ["R"][concat](pa.slice(-2));
+                } else {
+                    for (var k = 0, kk = pa.length; k < kk; k++) {
+                        r[k] = pa[k];
+                    }
+                }
+                switch (r[0]) {
+                    case "Z":
+                        x = mx;
+                        y = my;
+                        break;
+                    case "H":
+                        x = r[1];
+                        break;
+                    case "V":
+                        y = r[1];
+                        break;
+                    case "M":
+                        mx = r[r.length - 2];
+                        my = r[r.length - 1];
+                    default:
+                        x = r[r.length - 2];
+                        y = r[r.length - 1];
+                }
+            }
+            res.toString = R._path2string;
+            pth.abs = pathClone(res);
+            return res;
+        },
+        l2c = function (x1, y1, x2, y2) {
+            return [x1, y1, x2, y2, x2, y2];
+        },
+        q2c = function (x1, y1, ax, ay, x2, y2) {
+            var _13 = 1 / 3,
+                _23 = 2 / 3;
+            return [
+                    _13 * x1 + _23 * ax,
+                    _13 * y1 + _23 * ay,
+                    _13 * x2 + _23 * ax,
+                    _13 * y2 + _23 * ay,
+                    x2,
+                    y2
+                ];
+        },
+        a2c = function (x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {
+            // for more information of where this math came from visit:
+            // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
+            var _120 = PI * 120 / 180,
+                rad = PI / 180 * (+angle || 0),
+                res = [],
+                xy,
+                rotate = cacher(function (x, y, rad) {
+                    var X = x * math.cos(rad) - y * math.sin(rad),
+                        Y = x * math.sin(rad) + y * math.cos(rad);
+                    return {x: X, y: Y};
+                });
+            if (!recursive) {
+                xy = rotate(x1, y1, -rad);
+                x1 = xy.x;
+                y1 = xy.y;
+                xy = rotate(x2, y2, -rad);
+                x2 = xy.x;
+                y2 = xy.y;
+                var cos = math.cos(PI / 180 * angle),
+                    sin = math.sin(PI / 180 * angle),
+                    x = (x1 - x2) / 2,
+                    y = (y1 - y2) / 2;
+                var h = (x * x) / (rx * rx) + (y * y) / (ry * ry);
+                if (h > 1) {
+                    h = math.sqrt(h);
+                    rx = h * rx;
+                    ry = h * ry;
+                }
+                var rx2 = rx * rx,
+                    ry2 = ry * ry,
+                    k = (large_arc_flag == sweep_flag ? -1 : 1) *
+                        math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),
+                    cx = k * rx * y / ry + (x1 + x2) / 2,
+                    cy = k * -ry * x / rx + (y1 + y2) / 2,
+                    f1 = math.asin(((y1 - cy) / ry).toFixed(9)),
+                    f2 = math.asin(((y2 - cy) / ry).toFixed(9));
+
+                f1 = x1 < cx ? PI - f1 : f1;
+                f2 = x2 < cx ? PI - f2 : f2;
+                f1 < 0 && (f1 = PI * 2 + f1);
+                f2 < 0 && (f2 = PI * 2 + f2);
+                if (sweep_flag && f1 > f2) {
+                    f1 = f1 - PI * 2;
+                }
+                if (!sweep_flag && f2 > f1) {
+                    f2 = f2 - PI * 2;
+                }
+            } else {
+                f1 = recursive[0];
+                f2 = recursive[1];
+                cx = recursive[2];
+                cy = recursive[3];
+            }
+            var df = f2 - f1;
+            if (abs(df) > _120) {
+                var f2old = f2,
+                    x2old = x2,
+                    y2old = y2;
+                f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
+                x2 = cx + rx * math.cos(f2);
+                y2 = cy + ry * math.sin(f2);
+                res = a2c(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);
+            }
+            df = f2 - f1;
+            var c1 = math.cos(f1),
+                s1 = math.sin(f1),
+                c2 = math.cos(f2),
+                s2 = math.sin(f2),
+                t = math.tan(df / 4),
+                hx = 4 / 3 * rx * t,
+                hy = 4 / 3 * ry * t,
+                m1 = [x1, y1],
+                m2 = [x1 + hx * s1, y1 - hy * c1],
+                m3 = [x2 + hx * s2, y2 - hy * c2],
+                m4 = [x2, y2];
+            m2[0] = 2 * m1[0] - m2[0];
+            m2[1] = 2 * m1[1] - m2[1];
+            if (recursive) {
+                return [m2, m3, m4][concat](res);
+            } else {
+                res = [m2, m3, m4][concat](res).join()[split](",");
+                var newres = [];
+                for (var i = 0, ii = res.length; i < ii; i++) {
+                    newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x;
+                }
+                return newres;
+            }
+        },
+        findDotAtSegment = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
+            var t1 = 1 - t;
+            return {
+                x: pow(t1, 3) * p1x + pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + pow(t, 3) * p2x,
+                y: pow(t1, 3) * p1y + pow(t1, 2) * 3 * t * c1y + t1 * 3 * t * t * c2y + pow(t, 3) * p2y
+            };
+        },
+        curveDim = cacher(function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
+            var a = (c2x - 2 * c1x + p1x) - (p2x - 2 * c2x + c1x),
+                b = 2 * (c1x - p1x) - 2 * (c2x - c1x),
+                c = p1x - c1x,
+                t1 = (-b + math.sqrt(b * b - 4 * a * c)) / 2 / a,
+                t2 = (-b - math.sqrt(b * b - 4 * a * c)) / 2 / a,
+                y = [p1y, p2y],
+                x = [p1x, p2x],
+                dot;
+            abs(t1) > "1e12" && (t1 = .5);
+            abs(t2) > "1e12" && (t2 = .5);
+            if (t1 > 0 && t1 < 1) {
+                dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t1);
+                x.push(dot.x);
+                y.push(dot.y);
+            }
+            if (t2 > 0 && t2 < 1) {
+                dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t2);
+                x.push(dot.x);
+                y.push(dot.y);
+            }
+            a = (c2y - 2 * c1y + p1y) - (p2y - 2 * c2y + c1y);
+            b = 2 * (c1y - p1y) - 2 * (c2y - c1y);
+            c = p1y - c1y;
+            t1 = (-b + math.sqrt(b * b - 4 * a * c)) / 2 / a;
+            t2 = (-b - math.sqrt(b * b - 4 * a * c)) / 2 / a;
+            abs(t1) > "1e12" && (t1 = .5);
+            abs(t2) > "1e12" && (t2 = .5);
+            if (t1 > 0 && t1 < 1) {
+                dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t1);
+                x.push(dot.x);
+                y.push(dot.y);
+            }
+            if (t2 > 0 && t2 < 1) {
+                dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t2);
+                x.push(dot.x);
+                y.push(dot.y);
+            }
+            return {
+                min: {x: mmin[apply](0, x), y: mmin[apply](0, y)},
+                max: {x: mmax[apply](0, x), y: mmax[apply](0, y)}
+            };
+        }),
+        path2curve = R._path2curve = cacher(function (path, path2) {
+            var pth = !path2 && paths(path);
+            if (!path2 && pth.curve) {
+                return pathClone(pth.curve);
+            }
+            var p = pathToAbsolute(path),
+                p2 = path2 && pathToAbsolute(path2),
+                attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},
+                attrs2 = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},
+                processPath = function (path, d, pcom) {
+                    var nx, ny, tq = {T:1, Q:1};
+                    if (!path) {
+                        return ["C", d.x, d.y, d.x, d.y, d.x, d.y];
+                    }
+                    !(path[0] in tq) && (d.qx = d.qy = null);
+                    switch (path[0]) {
+                        case "M":
+                            d.X = path[1];
+                            d.Y = path[2];
+                            break;
+                        case "A":
+                            path = ["C"][concat](a2c[apply](0, [d.x, d.y][concat](path.slice(1))));
+                            break;
+                        case "S":
+                            if (pcom == "C" || pcom == "S") { // In "S" case we have to take into account, if the previous command is C/S.
+                                nx = d.x * 2 - d.bx;          // And reflect the previous
+                                ny = d.y * 2 - d.by;          // command's control point relative to the current point.
+                            }
+                            else {                            // or some else or nothing
+                                nx = d.x;
+                                ny = d.y;
+                            }
+                            path = ["C", nx, ny][concat](path.slice(1));
+                            break;
+                        case "T":
+                            if (pcom == "Q" || pcom == "T") { // In "T" case we have to take into account, if the previous command is Q/T.
+                                d.qx = d.x * 2 - d.qx;        // And make a reflection similar
+                                d.qy = d.y * 2 - d.qy;        // to case "S".
+                            }
+                            else {                            // or something else or nothing
+                                d.qx = d.x;
+                                d.qy = d.y;
+                            }
+                            path = ["C"][concat](q2c(d.x, d.y, d.qx, d.qy, path[1], path[2]));
+                            break;
+                        case "Q":
+                            d.qx = path[1];
+                            d.qy = path[2];
+                            path = ["C"][concat](q2c(d.x, d.y, path[1], path[2], path[3], path[4]));
+                            break;
+                        case "L":
+                            path = ["C"][concat](l2c(d.x, d.y, path[1], path[2]));
+                            break;
+                        case "H":
+                            path = ["C"][concat](l2c(d.x, d.y, path[1], d.y));
+                            break;
+                        case "V":
+                            path = ["C"][concat](l2c(d.x, d.y, d.x, path[1]));
+                            break;
+                        case "Z":
+                            path = ["C"][concat](l2c(d.x, d.y, d.X, d.Y));
+                            break;
+                    }
+                    return path;
+                },
+                fixArc = function (pp, i) {
+                    if (pp[i].length > 7) {
+                        pp[i].shift();
+                        var pi = pp[i];
+                        while (pi.length) {
+                            pp.splice(i++, 0, ["C"][concat](pi.splice(0, 6)));
+                        }
+                        pp.splice(i, 1);
+                        ii = mmax(p.length, p2 && p2.length || 0);
+                    }
+                },
+                fixM = function (path1, path2, a1, a2, i) {
+                    if (path1 && path2 && path1[i][0] == "M" && path2[i][0] != "M") {
+                        path2.splice(i, 0, ["M", a2.x, a2.y]);
+                        a1.bx = 0;
+                        a1.by = 0;
+                        a1.x = path1[i][1];
+                        a1.y = path1[i][2];
+                        ii = mmax(p.length, p2 && p2.length || 0);
+                    }
+                };
+            for (var i = 0, ii = mmax(p.length, p2 && p2.length || 0); i < ii; i++) {
+                p[i] = processPath(p[i], attrs);
+                fixArc(p, i);
+                p2 && (p2[i] = processPath(p2[i], attrs2));
+                p2 && fixArc(p2, i);
+                fixM(p, p2, attrs, attrs2, i);
+                fixM(p2, p, attrs2, attrs, i);
+                var seg = p[i],
+                    seg2 = p2 && p2[i],
+                    seglen = seg.length,
+                    seg2len = p2 && seg2.length;
+                attrs.x = seg[seglen - 2];
+                attrs.y = seg[seglen - 1];
+                attrs.bx = toFloat(seg[seglen - 4]) || attrs.x;
+                attrs.by = toFloat(seg[seglen - 3]) || attrs.y;
+                attrs2.bx = p2 && (toFloat(seg2[seg2len - 4]) || attrs2.x);
+                attrs2.by = p2 && (toFloat(seg2[seg2len - 3]) || attrs2.y);
+                attrs2.x = p2 && seg2[seg2len - 2];
+                attrs2.y = p2 && seg2[seg2len - 1];
+            }
+            if (!p2) {
+                pth.curve = pathClone(p);
+            }
+            return p2 ? [p, p2] : p;
+        }, null, pathClone),
+        parseDots = R._parseDots = cacher(function (gradient) {
+            var dots = [];
+            for (var i = 0, ii = gradient.length; i < ii; i++) {
+                var dot = {},
+                    par = gradient[i].match(/^([^:]*):?([\d\.]*)/);
+                dot.color = R.getRGB(par[1]);
+                if (dot.color.error) {
+                    return null;
+                }
+                dot.color = dot.color.hex;
+                par[2] && (dot.offset = par[2] + "%");
+                dots.push(dot);
+            }
+            for (i = 1, ii = dots.length - 1; i < ii; i++) {
+                if (!dots[i].offset) {
+                    var start = toFloat(dots[i - 1].offset || 0),
+                        end = 0;
+                    for (var j = i + 1; j < ii; j++) {
+                        if (dots[j].offset) {
+                            end = dots[j].offset;
+                            break;
+                        }
+                    }
+                    if (!end) {
+                        end = 100;
+                        j = ii;
+                    }
+                    end = toFloat(end);
+                    var d = (end - start) / (j - i + 1);
+                    for (; i < j; i++) {
+                        start += d;
+                        dots[i].offset = start + "%";
+                    }
+                }
+            }
+            return dots;
+        }),
+        tear = R._tear = function (el, paper) {
+            el == paper.top && (paper.top = el.prev);
+            el == paper.bottom && (paper.bottom = el.next);
+            el.next && (el.next.prev = el.prev);
+            el.prev && (el.prev.next = el.next);
+        },
+        tofront = R._tofront = function (el, paper) {
+            if (paper.top === el) {
+                return;
+            }
+            tear(el, paper);
+            el.next = null;
+            el.prev = paper.top;
+            paper.top.next = el;
+            paper.top = el;
+        },
+        toback = R._toback = function (el, paper) {
+            if (paper.bottom === el) {
+                return;
+            }
+            tear(el, paper);
+            el.next = paper.bottom;
+            el.prev = null;
+            paper.bottom.prev = el;
+            paper.bottom = el;
+        },
+        insertafter = R._insertafter = function (el, el2, paper) {
+            tear(el, paper);
+            el2 == paper.top && (paper.top = el);
+            el2.next && (el2.next.prev = el);
+            el.next = el2.next;
+            el.prev = el2;
+            el2.next = el;
+        },
+        insertbefore = R._insertbefore = function (el, el2, paper) {
+            tear(el, paper);
+            el2 == paper.bottom && (paper.bottom = el);
+            el2.prev && (el2.prev.next = el);
+            el.prev = el2.prev;
+            el2.prev = el;
+            el.next = el2;
+        },
+        /*\
+         * Raphael.toMatrix
+         [ method ]
+         **
+         * Utility method
+         **
+         * Returns matrix of transformations applied to a given path
+         > Parameters
+         - path (string) path string
+         - transform (string|array) transformation string
+         = (object) @Matrix
+        \*/
+        toMatrix = R.toMatrix = function (path, transform) {
+            var bb = pathDimensions(path),
+                el = {
+                    _: {
+                        transform: E
+                    },
+                    getBBox: function () {
+                        return bb;
+                    }
+                };
+            extractTransform(el, transform);
+            return el.matrix;
+        },
+        /*\
+         * Raphael.transformPath
+         [ method ]
+         **
+         * Utility method
+         **
+         * Returns path transformed by a given transformation
+         > Parameters
+         - path (string) path string
+         - transform (string|array) transformation string
+         = (string) path
+        \*/
+        transformPath = R.transformPath = function (path, transform) {
+            return mapPath(path, toMatrix(path, transform));
+        },
+        extractTransform = R._extractTransform = function (el, tstr) {
+            if (tstr == null) {
+                return el._.transform;
+            }
+            tstr = Str(tstr).replace(/\.{3}|\u2026/g, el._.transform || E);
+            var tdata = R.parseTransformString(tstr),
+                deg = 0,
+                dx = 0,
+                dy = 0,
+                sx = 1,
+                sy = 1,
+                _ = el._,
+                m = new Matrix;
+            _.transform = tdata || [];
+            if (tdata) {
+                for (var i = 0, ii = tdata.length; i < ii; i++) {
+                    var t = tdata[i],
+                        tlen = t.length,
+                        command = Str(t[0]).toLowerCase(),
+                        absolute = t[0] != command,
+                        inver = absolute ? m.invert() : 0,
+                        x1,
+                        y1,
+                        x2,
+                        y2,
+                        bb;
+                    if (command == "t" && tlen == 3) {
+                        if (absolute) {
+                            x1 = inver.x(0, 0);
+                            y1 = inver.y(0, 0);
+                            x2 = inver.x(t[1], t[2]);
+                            y2 = inver.y(t[1], t[2]);
+                            m.translate(x2 - x1, y2 - y1);
+                        } else {
+                            m.translate(t[1], t[2]);
+                        }
+                    } else if (command == "r") {
+                        if (tlen == 2) {
+                            bb = bb || el.getBBox(1);
+                            m.rotate(t[1], bb.x + bb.width / 2, bb.y + bb.height / 2);
+                            deg += t[1];
+                        } else if (tlen == 4) {
+                            if (absolute) {
+                                x2 = inver.x(t[2], t[3]);
+                                y2 = inver.y(t[2], t[3]);
+                                m.rotate(t[1], x2, y2);
+                            } else {
+                                m.rotate(t[1], t[2], t[3]);
+                            }
+                            deg += t[1];
+                        }
+                    } else if (command == "s") {
+                        if (tlen == 2 || tlen == 3) {
+                            bb = bb || el.getBBox(1);
+                            m.scale(t[1], t[tlen - 1], bb.x + bb.width / 2, bb.y + bb.height / 2);
+                            sx *= t[1];
+                            sy *= t[tlen - 1];
+                        } else if (tlen == 5) {
+                            if (absolute) {
+                                x2 = inver.x(t[3], t[4]);
+                                y2 = inver.y(t[3], t[4]);
+                                m.scale(t[1], t[2], x2, y2);
+                            } else {
+                                m.scale(t[1], t[2], t[3], t[4]);
+                            }
+                            sx *= t[1];
+                            sy *= t[2];
+                        }
+                    } else if (command == "m" && tlen == 7) {
+                        m.add(t[1], t[2], t[3], t[4], t[5], t[6]);
+                    }
+                    _.dirtyT = 1;
+                    el.matrix = m;
+                }
+            }
+
+            /*\
+             * Element.matrix
+             [ property (object) ]
+             **
+             * Keeps @Matrix object, which represents element transformation
+            \*/
+            el.matrix = m;
+
+            _.sx = sx;
+            _.sy = sy;
+            _.deg = deg;
+            _.dx = dx = m.e;
+            _.dy = dy = m.f;
+
+            if (sx == 1 && sy == 1 && !deg && _.bbox) {
+                _.bbox.x += +dx;
+                _.bbox.y += +dy;
+            } else {
+                _.dirtyT = 1;
+            }
+        },
+        getEmpty = function (item) {
+            var l = item[0];
+            switch (l.toLowerCase()) {
+                case "t": return [l, 0, 0];
+                case "m": return [l, 1, 0, 0, 1, 0, 0];
+                case "r": if (item.length == 4) {
+                    return [l, 0, item[2], item[3]];
+                } else {
+                    return [l, 0];
+                }
+                case "s": if (item.length == 5) {
+                    return [l, 1, 1, item[3], item[4]];
+                } else if (item.length == 3) {
+                    return [l, 1, 1];
+                } else {
+                    return [l, 1];
+                }
+            }
+        },
+        equaliseTransform = R._equaliseTransform = function (t1, t2) {
+            t2 = Str(t2).replace(/\.{3}|\u2026/g, t1);
+            t1 = R.parseTransformString(t1) || [];
+            t2 = R.parseTransformString(t2) || [];
+            var maxlength = mmax(t1.length, t2.length),
+                from = [],
+                to = [],
+                i = 0, j, jj,
+                tt1, tt2;
+            for (; i < maxlength; i++) {
+                tt1 = t1[i] || getEmpty(t2[i]);
+                tt2 = t2[i] || getEmpty(tt1);
+                if ((tt1[0] != tt2[0]) ||
+                    (tt1[0].toLowerCase() == "r" && (tt1[2] != tt2[2] || tt1[3] != tt2[3])) ||
+                    (tt1[0].toLowerCase() == "s" && (tt1[3] != tt2[3] || tt1[4] != tt2[4]))
+                    ) {
+                    return;
+                }
+                from[i] = [];
+                to[i] = [];
+                for (j = 0, jj = mmax(tt1.length, tt2.length); j < jj; j++) {
+                    j in tt1 && (from[i][j] = tt1[j]);
+                    j in tt2 && (to[i][j] = tt2[j]);
+                }
+            }
+            return {
+                from: from,
+                to: to
+            };
+        };
+    R._getContainer = function (x, y, w, h) {
+        var container;
+        container = h == null && !R.is(x, "object") ? g.doc.getElementById(x) : x;
+        if (container == null) {
+            return;
+        }
+        if (container.tagName) {
+            if (y == null) {
+                return {
+                    container: container,
+                    width: container.style.pixelWidth || container.offsetWidth,
+                    height: container.style.pixelHeight || container.offsetHeight
+                };
+            } else {
+                return {
+                    container: container,
+                    width: y,
+                    height: w
+                };
+            }
+        }
+        return {
+            container: 1,
+            x: x,
+            y: y,
+            width: w,
+            height: h
+        };
+    };
+    /*\
+     * Raphael.pathToRelative
+     [ method ]
+     **
+     * Utility method
+     **
+     * Converts path to relative form
+     > Parameters
+     - pathString (string|array) path string or array of segments
+     = (array) array of segments.
+    \*/
+    R.pathToRelative = pathToRelative;
+    R._engine = {};
+    /*\
+     * Raphael.path2curve
+     [ method ]
+     **
+     * Utility method
+     **
+     * Converts path to a new path where all segments are cubic bezier curves.
+     > Parameters
+     - pathString (string|array) path string or array of segments
+     = (array) array of segments.
+    \*/
+    R.path2curve = path2curve;
+    /*\
+     * Raphael.matrix
+     [ method ]
+     **
+     * Utility method
+     **
+     * Returns matrix based on given parameters.
+     > Parameters
+     - a (number)
+     - b (number)
+     - c (number)
+     - d (number)
+     - e (number)
+     - f (number)
+     = (object) @Matrix
+    \*/
+    R.matrix = function (a, b, c, d, e, f) {
+        return new Matrix(a, b, c, d, e, f);
+    };
+    function Matrix(a, b, c, d, e, f) {
+        if (a != null) {
+            this.a = +a;
+            this.b = +b;
+            this.c = +c;
+            this.d = +d;
+            this.e = +e;
+            this.f = +f;
+        } else {
+            this.a = 1;
+            this.b = 0;
+            this.c = 0;
+            this.d = 1;
+            this.e = 0;
+            this.f = 0;
+        }
+    }
+    (function (matrixproto) {
+        /*\
+         * Matrix.add
+         [ method ]
+         **
+         * Adds given matrix to existing one.
+         > Parameters
+         - a (number)
+         - b (number)
+         - c (number)
+         - d (number)
+         - e (number)
+         - f (number)
+         or
+         - matrix (object) @Matrix
+        \*/
+        matrixproto.add = function (a, b, c, d, e, f) {
+            var out = [[], [], []],
+                m = [[this.a, this.c, this.e], [this.b, this.d, this.f], [0, 0, 1]],
+                matrix = [[a, c, e], [b, d, f], [0, 0, 1]],
+                x, y, z, res;
+
+            if (a && a instanceof Matrix) {
+                matrix = [[a.a, a.c, a.e], [a.b, a.d, a.f], [0, 0, 1]];
+            }
+
+            for (x = 0; x < 3; x++) {
+                for (y = 0; y < 3; y++) {
+                    res = 0;
+                    for (z = 0; z < 3; z++) {
+                        res += m[x][z] * matrix[z][y];
+                    }
+                    out[x][y] = res;
+                }
+            }
+            this.a = out[0][0];
+            this.b = out[1][0];
+            this.c = out[0][1];
+            this.d = out[1][1];
+            this.e = out[0][2];
+            this.f = out[1][2];
+        };
+        /*\
+         * Matrix.invert
+         [ method ]
+         **
+         * Returns inverted version of the matrix
+         = (object) @Matrix
+        \*/
+        matrixproto.invert = function () {
+            var me = this,
+                x = me.a * me.d - me.b * me.c;
+            return new Matrix(me.d / x, -me.b / x, -me.c / x, me.a / x, (me.c * me.f - me.d * me.e) / x, (me.b * me.e - me.a * me.f) / x);
+        };
+        /*\
+         * Matrix.clone
+         [ method ]
+         **
+         * Returns copy of the matrix
+         = (object) @Matrix
+        \*/
+        matrixproto.clone = function () {
+            return new Matrix(this.a, this.b, this.c, this.d, this.e, this.f);
+        };
+        /*\
+         * Matrix.translate
+         [ method ]
+         **
+         * Translate the matrix
+         > Parameters
+         - x (number)
+         - y (number)
+        \*/
+        matrixproto.translate = function (x, y) {
+            this.add(1, 0, 0, 1, x, y);
+        };
+        /*\
+         * Matrix.scale
+         [ method ]
+         **
+         * Scales the matrix
+         > Parameters
+         - x (number)
+         - y (number) #optional
+         - cx (number) #optional
+         - cy (number) #optional
+        \*/
+        matrixproto.scale = function (x, y, cx, cy) {
+            y == null && (y = x);
+            (cx || cy) && this.add(1, 0, 0, 1, cx, cy);
+            this.add(x, 0, 0, y, 0, 0);
+            (cx || cy) && this.add(1, 0, 0, 1, -cx, -cy);
+        };
+        /*\
+         * Matrix.rotate
+         [ method ]
+         **
+         * Rotates the matrix
+         > Parameters
+         - a (number)
+         - x (number)
+         - y (number)
+        \*/
+        matrixproto.rotate = function (a, x, y) {
+            a = R.rad(a);
+            x = x || 0;
+            y = y || 0;
+            var cos = +math.cos(a).toFixed(9),
+                sin = +math.sin(a).toFixed(9);
+            this.add(cos, sin, -sin, cos, x, y);
+            this.add(1, 0, 0, 1, -x, -y);
+        };
+        /*\
+         * Matrix.x
+         [ method ]
+         **
+         * Return x coordinate for given point after transformation described by the matrix. See also @Matrix.y
+         > Parameters
+         - x (number)
+         - y (number)
+         = (number) x
+        \*/
+        matrixproto.x = function (x, y) {
+            return x * this.a + y * this.c + this.e;
+        };
+        /*\
+         * Matrix.y
+         [ method ]
+         **
+         * Return y coordinate for given point after transformation described by the matrix. See also @Matrix.x
+         > Parameters
+         - x (number)
+         - y (number)
+         = (number) y
+        \*/
+        matrixproto.y = function (x, y) {
+            return x * this.b + y * this.d + this.f;
+        };
+        matrixproto.get = function (i) {
+            return +this[Str.fromCharCode(97 + i)].toFixed(4);
+        };
+        matrixproto.toString = function () {
+            return R.svg ?
+                "matrix(" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)].join() + ")" :
+                [this.get(0), this.get(2), this.get(1), this.get(3), 0, 0].join();
+        };
+        matrixproto.toFilter = function () {
+            return "progid:DXImageTransform.Microsoft.Matrix(M11=" + this.get(0) +
+                ", M12=" + this.get(2) + ", M21=" + this.get(1) + ", M22=" + this.get(3) +
+                ", Dx=" + this.get(4) + ", Dy=" + this.get(5) + ", sizingmethod='auto expand')";
+        };
+        matrixproto.offset = function () {
+            return [this.e.toFixed(4), this.f.toFixed(4)];
+        };
+        function norm(a) {
+            return a[0] * a[0] + a[1] * a[1];
+        }
+        function normalize(a) {
+            var mag = math.sqrt(norm(a));
+            a[0] && (a[0] /= mag);
+            a[1] && (a[1] /= mag);
+        }
+        /*\
+         * Matrix.split
+         [ method ]
+         **
+         * Splits matrix into primitive transformations
+         = (object) in format:
+         o dx (number) translation by x
+         o dy (number) translation by y
+         o scalex (number) scale by x
+         o scaley (number) scale by y
+         o shear (number) shear
+         o rotate (number) rotation in deg
+         o isSimple (boolean) could it be represented via simple transformations
+        \*/
+        matrixproto.split = function () {
+            var out = {};
+            // translation
+            out.dx = this.e;
+            out.dy = this.f;
+
+            // scale and shear
+            var row = [[this.a, this.c], [this.b, this.d]];
+            out.scalex = math.sqrt(norm(row[0]));
+            normalize(row[0]);
+
+            out.shear = row[0][0] * row[1][0] + row[0][1] * row[1][1];
+            row[1] = [row[1][0] - row[0][0] * out.shear, row[1][1] - row[0][1] * out.shear];
+
+            out.scaley = math.sqrt(norm(row[1]));
+            normalize(row[1]);
+            out.shear /= out.scaley;
+
+            // rotation
+            var sin = -row[0][1],
+                cos = row[1][1];
+            if (cos < 0) {
+                out.rotate = R.deg(math.acos(cos));
+                if (sin < 0) {
+                    out.rotate = 360 - out.rotate;
+                }
+            } else {
+                out.rotate = R.deg(math.asin(sin));
+            }
+
+            out.isSimple = !+out.shear.toFixed(9) && (out.scalex.toFixed(9) == out.scaley.toFixed(9) || !out.rotate);
+            out.isSuperSimple = !+out.shear.toFixed(9) && out.scalex.toFixed(9) == out.scaley.toFixed(9) && !out.rotate;
+            out.noRotation = !+out.shear.toFixed(9) && !out.rotate;
+            return out;
+        };
+        /*\
+         * Matrix.toTransformString
+         [ method ]
+         **
+         * Return transform string that represents given matrix
+         = (string) transform string
+        \*/
+        matrixproto.toTransformString = function (shorter) {
+            var s = shorter || this[split]();
+            if (s.isSimple) {
+                s.scalex = +s.scalex.toFixed(4);
+                s.scaley = +s.scaley.toFixed(4);
+                s.rotate = +s.rotate.toFixed(4);
+                return  (s.dx || s.dy ? "t" + [s.dx, s.dy] : E) +
+                        (s.scalex != 1 || s.scaley != 1 ? "s" + [s.scalex, s.scaley, 0, 0] : E) +
+                        (s.rotate ? "r" + [s.rotate, 0, 0] : E);
+            } else {
+                return "m" + [this.get(0), this.get(1), this.get(2), this.get(3), this.get(4), this.get(5)];
+            }
+        };
+    })(Matrix.prototype);
+
+    // WebKit rendering bug workaround method
+    var version = navigator.userAgent.match(/Version\/(.*?)\s/) || navigator.userAgent.match(/Chrome\/(\d+)/);
+    if ((navigator.vendor == "Apple Computer, Inc.") && (version && version[1] < 4 || navigator.platform.slice(0, 2) == "iP") ||
+        (navigator.vendor == "Google Inc." && version && version[1] < 8)) {
+        /*\
+         * Paper.safari
+         [ method ]
+         **
+         * There is an inconvenient rendering bug in Safari (WebKit):
+         * sometimes the rendering should be forced.
+         * This method should help with dealing with this bug.
+        \*/
+        paperproto.safari = function () {
+            var rect = this.rect(-99, -99, this.width + 99, this.height + 99).attr({stroke: "none"});
+            setTimeout(function () {rect.remove();});
+        };
+    } else {
+        paperproto.safari = fun;
+    }
+
+    var preventDefault = function () {
+        this.returnValue = false;
+    },
+    preventTouch = function () {
+        return this.originalEvent.preventDefault();
+    },
+    stopPropagation = function () {
+        this.cancelBubble = true;
+    },
+    stopTouch = function () {
+        return this.originalEvent.stopPropagation();
+    },
+    getEventPosition = function (e) {
+        var scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop,
+            scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft;
+
+        return {
+            x: e.clientX + scrollX,
+            y: e.clientY + scrollY
+        };
+    },
+    addEvent = (function () {
+        if (g.doc.addEventListener) {
+            return function (obj, type, fn, element) {
+                var f = function (e) {
+                    var pos = getEventPosition(e);
+                    return fn.call(element, e, pos.x, pos.y);
+                };
+                obj.addEventListener(type, f, false);
+
+                if (supportsTouch && touchMap[type]) {
+                    var _f = function (e) {
+                        var pos = getEventPosition(e),
+                            olde = e;
+
+                        for (var i = 0, ii = e.targetTouches && e.targetTouches.length; i < ii; i++) {
+                            if (e.targetTouches[i].target == obj) {
+                                e = e.targetTouches[i];
+                                e.originalEvent = olde;
+                                e.preventDefault = preventTouch;
+                                e.stopPropagation = stopTouch;
+                                break;
+                            }
+                        }
+
+                        return fn.call(element, e, pos.x, pos.y);
+                    };
+                    obj.addEventListener(touchMap[type], _f, false);
+                }
+
+                return function () {
+                    obj.removeEventListener(type, f, false);
+
+                    if (supportsTouch && touchMap[type])
+                        obj.removeEventListener(touchMap[type], f, false);
+
+                    return true;
+                };
+            };
+        } else if (g.doc.attachEvent) {
+            return function (obj, type, fn, element) {
+                var f = function (e) {
+                    e = e || g.win.event;
+                    var scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop,
+                        scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft,
+                        x = e.clientX + scrollX,
+                        y = e.clientY + scrollY;
+                    e.preventDefault = e.preventDefault || preventDefault;
+                    e.stopPropagation = e.stopPropagation || stopPropagation;
+                    return fn.call(element, e, x, y);
+                };
+                obj.attachEvent("on" + type, f);
+                var detacher = function () {
+                    obj.detachEvent("on" + type, f);
+                    return true;
+                };
+                return detacher;
+            };
+        }
+    })(),
+    drag = [],
+    dragMove = function (e) {
+        var x = e.clientX,
+            y = e.clientY,
+            scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop,
+            scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft,
+            dragi,
+            j = drag.length;
+        while (j--) {
+            dragi = drag[j];
+            if (supportsTouch && e.touches) {
+                var i = e.touches.length,
+                    touch;
+                while (i--) {
+                    touch = e.touches[i];
+                    if (touch.identifier == dragi.el._drag.id) {
+                        x = touch.clientX;
+                        y = touch.clientY;
+                        (e.originalEvent ? e.originalEvent : e).preventDefault();
+                        break;
+                    }
+                }
+            } else {
+                e.preventDefault();
+            }
+            var node = dragi.el.node,
+                o,
+                next = node.nextSibling,
+                parent = node.parentNode,
+                display = node.style.display;
+            g.win.opera && parent.removeChild(node);
+            node.style.display = "none";
+            o = dragi.el.paper.getElementByPoint(x, y);
+            node.style.display = display;
+            g.win.opera && (next ? parent.insertBefore(node, next) : parent.appendChild(node));
+            o && eve("raphael.drag.over." + dragi.el.id, dragi.el, o);
+            x += scrollX;
+            y += scrollY;
+            eve("raphael.drag.move." + dragi.el.id, dragi.move_scope || dragi.el, x - dragi.el._drag.x, y - dragi.el._drag.y, x, y, e);
+        }
+    },
+    dragUp = function (e) {
+        R.unmousemove(dragMove).unmouseup(dragUp);
+        var i = drag.length,
+            dragi;
+        while (i--) {
+            dragi = drag[i];
+            dragi.el._drag = {};
+            eve("raphael.drag.end." + dragi.el.id, dragi.end_scope || dragi.start_scope || dragi.move_scope || dragi.el, e);
+        }
+        drag = [];
+    },
+    /*\
+     * Raphael.el
+     [ property (object) ]
+     **
+     * You can add your own method to elements. This is usefull when you want to hack default functionality or
+     * want to wrap some common transformation or attributes in one method. In difference to canvas methods,
+     * you can redefine element method at any time. Expending element methods wouldn’t affect set.
+     > Usage
+     | Raphael.el.red = function () {
+     |     this.attr({fill: "#f00"});
+     | };
+     | // then use it
+     | paper.circle(100, 100, 20).red();
+    \*/
+    elproto = R.el = {};
+    /*\
+     * Element.click
+     [ method ]
+     **
+     * Adds event handler for click for the element.
+     > Parameters
+     - handler (function) handler for the event
+     = (object) @Element
+    \*/
+    /*\
+     * Element.unclick
+     [ method ]
+     **
+     * Removes event handler for click for the element.
+     > Parameters
+     - handler (function) #optional handler for the event
+     = (object) @Element
+    \*/
+
+    /*\
+     * Element.dblclick
+     [ method ]
+     **
+     * Adds event handler for double click for the element.
+     > Parameters
+     - handler (function) handler for the event
+     = (object) @Element
+    \*/
+    /*\
+     * Element.undblclick
+     [ method ]
+     **
+     * Removes event handler for double click for the element.
+     > Parameters
+     - handler (function) #optional handler for the event
+     = (object) @Element
+    \*/
+
+    /*\
+     * Element.mousedown
+     [ method ]
+     **
+     * Adds event handler for mousedown for the element.
+     > Parameters
+     - handler (function) handler for the event
+     = (object) @Element
+    \*/
+    /*\
+     * Element.unmousedown
+     [ method ]
+     **
+     * Removes event handler for mousedown for the element.
+     > Parameters
+     - handler (function) #optional handler for the event
+     = (object) @Element
+    \*/
+
+    /*\
+     * Element.mousemove
+     [ method ]
+     **
+     * Adds event handler for mousemove for the element.
+     > Parameters
+     - handler (function) handler for the event
+     = (object) @Element
+    \*/
+    /*\
+     * Element.unmousemove
+     [ method ]
+     **
+     * Removes event handler for mousemove for the element.
+     > Parameters
+     - handler (function) #optional handler for the event
+     = (object) @Element
+    \*/
+
+    /*\
+     * Element.mouseout
+     [ method ]
+     **
+     * Adds event handler for mouseout for the element.
+     > Parameters
+     - handler (function) handler for the event
+     = (object) @Element
+    \*/
+    /*\
+     * Element.unmouseout
+     [ method ]
+     **
+     * Removes event handler for mouseout for the element.
+     > Parameters
+     - handler (function) #optional handler for the event
+     = (object) @Element
+    \*/
+
+    /*\
+     * Element.mouseover
+     [ method ]
+     **
+     * Adds event handler for mouseover for the element.
+     > Parameters
+     - handler (function) handler for the event
+     = (object) @Element
+    \*/
+    /*\
+     * Element.unmouseover
+     [ method ]
+     **
+     * Removes event handler for mouseover for the element.
+     > Parameters
+     - handler (function) #optional handler for the event
+     = (object) @Element
+    \*/
+
+    /*\
+     * Element.mouseup
+     [ method ]
+     **
+     * Adds event handler for mouseup for the element.
+     > Parameters
+     - handler (function) handler for the event
+     = (object) @Element
+    \*/
+    /*\
+     * Element.unmouseup
+     [ method ]
+     **
+     * Removes event handler for mouseup for the element.
+     > Parameters
+     - handler (function) #optional handler for the event
+     = (object) @Element
+    \*/
+
+    /*\
+     * Element.touchstart
+     [ method ]
+     **
+     * Adds event handler for touchstart for the element.
+     > Parameters
+     - handler (function) handler for the event
+     = (object) @Element
+    \*/
+    /*\
+     * Element.untouchstart
+     [ method ]
+     **
+     * Removes event handler for touchstart for the element.
+     > Parameters
+     - handler (function) #optional handler for the event
+     = (object) @Element
+    \*/
+
+    /*\
+     * Element.touchmove
+     [ method ]
+     **
+     * Adds event handler for touchmove for the element.
+     > Parameters
+     - handler (function) handler for the event
+     = (object) @Element
+    \*/
+    /*\
+     * Element.untouchmove
+     [ method ]
+     **
+     * Removes event handler for touchmove for the element.
+     > Parameters
+     - handler (function) #optional handler for the event
+     = (object) @Element
+    \*/
+
+    /*\
+     * Element.touchend
+     [ method ]
+     **
+     * Adds event handler for touchend for the element.
+     > Parameters
+     - handler (function) handler for the event
+     = (object) @Element
+    \*/
+    /*\
+     * Element.untouchend
+     [ method ]
+     **
+     * Removes event handler for touchend for the element.
+     > Parameters
+     - handler (function) #optional handler for the event
+     = (object) @Element
+    \*/
+
+    /*\
+     * Element.touchcancel
+     [ method ]
+     **
+     * Adds event handler for touchcancel for the element.
+     > Parameters
+     - handler (function) handler for the event
+     = (object) @Element
+    \*/
+    /*\
+     * Element.untouchcancel
+     [ method ]
+     **
+     * Removes event handler for touchcancel for the element.
+     > Parameters
+     - handler (function) #optional handler for the event
+     = (object) @Element
+    \*/
+    for (var i = events.length; i--;) {
+        (function (eventName) {
+            R[eventName] = elproto[eventName] = function (fn, scope) {
+                if (R.is(fn, "function")) {
+                    this.events = this.events || [];
+                    this.events.push({name: eventName, f: fn, unbind: addEvent(this.shape || this.node || g.doc, eventName, fn, scope || this)});
+                }
+                return this;
+            };
+            R["un" + eventName] = elproto["un" + eventName] = function (fn) {
+                var events = this.events || [],
+                    l = events.length;
+                while (l--){
+                    if (events[l].name == eventName && (R.is(fn, "undefined") || events[l].f == fn)) {
+                        events[l].unbind();
+                        events.splice(l, 1);
+                        !events.length && delete this.events;
+                    }
+                }
+                return this;
+            };
+        })(events[i]);
+    }
+
+    /*\
+     * Element.data
+     [ method ]
+     **
+     * Adds or retrieves given value asociated with given key.
+     ** 
+     * See also @Element.removeData
+     > Parameters
+     - key (string) key to store data
+     - value (any) #optional value to store
+     = (object) @Element
+     * or, if value is not specified:
+     = (any) value
+     * or, if key and value are not specified:
+     = (object) Key/value pairs for all the data associated with the element.
+     > Usage
+     | for (var i = 0, i < 5, i++) {
+     |     paper.circle(10 + 15 * i, 10, 10)
+     |          .attr({fill: "#000"})
+     |          .data("i", i)
+     |          .click(function () {
+     |             alert(this.data("i"));
+     |          });
+     | }
+    \*/
+    elproto.data = function (key, value) {
+        var data = eldata[this.id] = eldata[this.id] || {};
+        if (arguments.length == 0) {
+            return data;
+        }
+        if (arguments.length == 1) {
+            if (R.is(key, "object")) {
+                for (var i in key) if (key[has](i)) {
+                    this.data(i, key[i]);
+                }
+                return this;
+            }
+            eve("raphael.data.get." + this.id, this, data[key], key);
+            return data[key];
+        }
+        data[key] = value;
+        eve("raphael.data.set." + this.id, this, value, key);
+        return this;
+    };
+    /*\
+     * Element.removeData
+     [ method ]
+     **
+     * Removes value associated with an element by given key.
+     * If key is not provided, removes all the data of the element.
+     > Parameters
+     - key (string) #optional key
+     = (object) @Element
+    \*/
+    elproto.removeData = function (key) {
+        if (key == null) {
+            eldata[this.id] = {};
+        } else {
+            eldata[this.id] && delete eldata[this.id][key];
+        }
+        return this;
+    };
+     /*\
+     * Element.getData
+     [ method ]
+     **
+     * Retrieves the element data
+     = (object) data
+    \*/
+    elproto.getData = function () {
+        return clone(eldata[this.id] || {});
+    };
+    /*\
+     * Element.hover
+     [ method ]
+     **
+     * Adds event handlers for hover for the element.
+     > Parameters
+     - f_in (function) handler for hover in
+     - f_out (function) handler for hover out
+     - icontext (object) #optional context for hover in handler
+     - ocontext (object) #optional context for hover out handler
+     = (object) @Element
+    \*/
+    elproto.hover = function (f_in, f_out, scope_in, scope_out) {
+        return this.mouseover(f_in, scope_in).mouseout(f_out, scope_out || scope_in);
+    };
+    /*\
+     * Element.unhover
+     [ method ]
+     **
+     * Removes event handlers for hover for the element.
+     > Parameters
+     - f_in (function) handler for hover in
+     - f_out (function) handler for hover out
+     = (object) @Element
+    \*/
+    elproto.unhover = function (f_in, f_out) {
+        return this.unmouseover(f_in).unmouseout(f_out);
+    };
+    var draggable = [];
+    /*\
+     * Element.drag
+     [ method ]
+     **
+     * Adds event handlers for drag of the element.
+     > Parameters
+     - onmove (function) handler for moving
+     - onstart (function) handler for drag start
+     - onend (function) handler for drag end
+     - mcontext (object) #optional context for moving handler
+     - scontext (object) #optional context for drag start handler
+     - econtext (object) #optional context for drag end handler
+     * Additionaly following `drag` events will be triggered: `drag.start.<id>` on start, 
+     * `drag.end.<id>` on end and `drag.move.<id>` on every move. When element will be dragged over another element 
+     * `drag.over.<id>` will be fired as well.
+     *
+     * Start event and start handler will be called in specified context or in context of the element with following parameters:
+     o x (number) x position of the mouse
+     o y (number) y position of the mouse
+     o event (object) DOM event object
+     * Move event and move handler will be called in specified context or in context of the element with following parameters:
+     o dx (number) shift by x from the start point
+     o dy (number) shift by y from the start point
+     o x (number) x position of the mouse
+     o y (number) y position of the mouse
+     o event (object) DOM event object
+     * End event and end handler will be called in specified context or in context of the element with following parameters:
+     o event (object) DOM event object
+     = (object) @Element
+    \*/
+    elproto.drag = function (onmove, onstart, onend, move_scope, start_scope, end_scope) {
+        function start(e) {
+            (e.originalEvent || e).preventDefault();
+            var x = e.clientX,
+                y = e.clientY,
+                scrollY = g.doc.documentElement.scrollTop || g.doc.body.scrollTop,
+                scrollX = g.doc.documentElement.scrollLeft || g.doc.body.scrollLeft;
+            this._drag.id = e.identifier;
+            if (supportsTouch && e.touches) {
+                var i = e.touches.length, touch;
+                while (i--) {
+                    touch = e.touches[i];
+                    this._drag.id = touch.identifier;
+                    if (touch.identifier == this._drag.id) {
+                        x = touch.clientX;
+                        y = touch.clientY;
+                        break;
+                    }
+                }
+            }
+            this._drag.x = x + scrollX;
+            this._drag.y = y + scrollY;
+            !drag.length && R.mousemove(dragMove).mouseup(dragUp);
+            drag.push({el: this, move_scope: move_scope, start_scope: start_scope, end_scope: end_scope});
+            onstart && eve.on("raphael.drag.start." + this.id, onstart);
+            onmove && eve.on("raphael.drag.move." + this.id, onmove);
+            onend && eve.on("raphael.drag.end." + this.id, onend);
+            eve("raphael.drag.start." + this.id, start_scope || move_scope || this, e.clientX + scrollX, e.clientY + scrollY, e);
+        }
+        this._drag = {};
+        draggable.push({el: this, start: start});
+        this.mousedown(start);
+        return this;
+    };
+    /*\
+     * Element.onDragOver
+     [ method ]
+     **
+     * Shortcut for assigning event handler for `drag.over.<id>` event, where id is id of the element (see @Element.id).
+     > Parameters
+     - f (function) handler for event, first argument would be the element you are dragging over
+    \*/
+    elproto.onDragOver = function (f) {
+        f ? eve.on("raphael.drag.over." + this.id, f) : eve.unbind("raphael.drag.over." + this.id);
+    };
+    /*\
+     * Element.undrag
+     [ method ]
+     **
+     * Removes all drag event handlers from given element.
+    \*/
+    elproto.undrag = function () {
+        var i = draggable.length;
+        while (i--) if (draggable[i].el == this) {
+            this.unmousedown(draggable[i].start);
+            draggable.splice(i, 1);
+            eve.unbind("raphael.drag.*." + this.id);
+        }
+        !draggable.length && R.unmousemove(dragMove).unmouseup(dragUp);
+        drag = [];
+    };
+    /*\
+     * Paper.circle
+     [ method ]
+     **
+     * Draws a circle.
+     **
+     > Parameters
+     **
+     - x (number) x coordinate of the centre
+     - y (number) y coordinate of the centre
+     - r (number) radius
+     = (object) Raphaël element object with type “circle”
+     **
+     > Usage
+     | var c = paper.circle(50, 50, 40);
+    \*/
+    paperproto.circle = function (x, y, r) {
+        var out = R._engine.circle(this, x || 0, y || 0, r || 0);
+        this.__set__ && this.__set__.push(out);
+        return out;
+    };
+    /*\
+     * Paper.rect
+     [ method ]
+     *
+     * Draws a rectangle.
+     **
+     > Parameters
+     **
+     - x (number) x coordinate of the top left corner
+     - y (number) y coordinate of the top left corner
+     - width (number) width
+     - height (number) height
+     - r (number) #optional radius for rounded corners, default is 0
+     = (object) Raphaël element object with type “rect”
+     **
+     > Usage
+     | // regular rectangle
+     | var c = paper.rect(10, 10, 50, 50);
+     | // rectangle with rounded corners
+     | var c = paper.rect(40, 40, 50, 50, 10);
+    \*/
+    paperproto.rect = function (x, y, w, h, r) {
+        var out = R._engine.rect(this, x || 0, y || 0, w || 0, h || 0, r || 0);
+        this.__set__ && this.__set__.push(out);
+        return out;
+    };
+    /*\
+     * Paper.ellipse
+     [ method ]
+     **
+     * Draws an ellipse.
+     **
+     > Parameters
+     **
+     - x (number) x coordinate of the centre
+     - y (number) y coordinate of the centre
+     - rx (number) horizontal radius
+     - ry (number) vertical radius
+     = (object) Raphaël element object with type “ellipse”
+     **
+     > Usage
+     | var c = paper.ellipse(50, 50, 40, 20);
+    \*/
+    paperproto.ellipse = function (x, y, rx, ry) {
+        var out = R._engine.ellipse(this, x || 0, y || 0, rx || 0, ry || 0);
+        this.__set__ && this.__set__.push(out);
+        return out;
+    };
+    /*\
+     * Paper.path
+     [ method ]
+     **
+     * Creates a path element by given path data string.
+     > Parameters
+     - pathString (string) #optional path string in SVG format.
+     * Path string consists of one-letter commands, followed by comma seprarated arguments in numercal form. Example:
+     | "M10,20L30,40"
+     * Here we can see two commands: “M”, with arguments `(10, 20)` and “L” with arguments `(30, 40)`. Upper case letter mean command is absolute, lower case—relative.
+     *
+     # <p>Here is short list of commands available, for more details see <a href="http://www.w3.org/TR/SVG/paths.html#PathData" title="Details of a path's data attribute's format are described in the SVG specification.">SVG path string format</a>.</p>
+     # <table><thead><tr><th>Command</th><th>Name</th><th>Parameters</th></tr></thead><tbody>
+     # <tr><td>M</td><td>moveto</td><td>(x y)+</td></tr>
+     # <tr><td>Z</td><td>closepath</td><td>(none)</td></tr>
+     # <tr><td>L</td><td>lineto</td><td>(x y)+</td></tr>
+     # <tr><td>H</td><td>horizontal lineto</td><td>x+</td></tr>
+     # <tr><td>V</td><td>vertical lineto</td><td>y+</td></tr>
+     # <tr><td>C</td><td>curveto</td><td>(x1 y1 x2 y2 x y)+</td></tr>
+     # <tr><td>S</td><td>smooth curveto</td><td>(x2 y2 x y)+</td></tr>
+     # <tr><td>Q</td><td>quadratic Bézier curveto</td><td>(x1 y1 x y)+</td></tr>
+     # <tr><td>T</td><td>smooth quadratic Bézier curveto</td><td>(x y)+</td></tr>
+     # <tr><td>A</td><td>elliptical arc</td><td>(rx ry x-axis-rotation large-arc-flag sweep-flag x y)+</td></tr>
+     # <tr><td>R</td><td><a href="http://en.wikipedia.org/wiki/Catmull–Rom_spline#Catmull.E2.80.93Rom_spline">Catmull-Rom curveto</a>*</td><td>x1 y1 (x y)+</td></tr></tbody></table>
+     * * “Catmull-Rom curveto” is a not standard SVG command and added in 2.0 to make life easier.
+     * Note: there is a special case when path consist of just three commands: “M10,10R…z”. In this case path will smoothly connects to its beginning.
+     > Usage
+     | var c = paper.path("M10 10L90 90");
+     | // draw a diagonal line:
+     | // move to 10,10, line to 90,90
+     * For example of path strings, check out these icons: http://raphaeljs.com/icons/
+    \*/
+    paperproto.path = function (pathString) {
+        pathString && !R.is(pathString, string) && !R.is(pathString[0], array) && (pathString += E);
+        var out = R._engine.path(R.format[apply](R, arguments), this);
+        this.__set__ && this.__set__.push(out);
+        return out;
+    };
+    /*\
+     * Paper.image
+     [ method ]
+     **
+     * Embeds an image into the surface.
+     **
+     > Parameters
+     **
+     - src (string) URI of the source image
+     - x (number) x coordinate position
+     - y (number) y coordinate position
+     - width (number) width of the image
+     - height (number) height of the image
+     = (object) Raphaël element object with type “image”
+     **
+     > Usage
+     | var c = paper.image("apple.png", 10, 10, 80, 80);
+    \*/
+    paperproto.image = function (src, x, y, w, h) {
+        var out = R._engine.image(this, src || "about:blank", x || 0, y || 0, w || 0, h || 0);
+        this.__set__ && this.__set__.push(out);
+        return out;
+    };
+    /*\
+     * Paper.text
+     [ method ]
+     **
+     * Draws a text string. If you need line breaks, put “\n” in the string.
+     **
+     > Parameters
+     **
+     - x (number) x coordinate position
+     - y (number) y coordinate position
+     - text (string) The text string to draw
+     = (object) Raphaël element object with type “text”
+     **
+     > Usage
+     | var t = paper.text(50, 50, "Raphaël\nkicks\nbutt!");
+    \*/
+    paperproto.text = function (x, y, text) {
+        var out = R._engine.text(this, x || 0, y || 0, Str(text));
+        this.__set__ && this.__set__.push(out);
+        return out;
+    };
+    /*\
+     * Paper.set
+     [ method ]
+     **
+     * Creates array-like object to keep and operate several elements at once.
+     * Warning: it doesn’t create any elements for itself in the page, it just groups existing elements.
+     * Sets act as pseudo elements — all methods available to an element can be used on a set.
+     = (object) array-like object that represents set of elements
+     **
+     > Usage
+     | var st = paper.set();
+     | st.push(
+     |     paper.circle(10, 10, 5),
+     |     paper.circle(30, 10, 5)
+     | );
+     | st.attr({fill: "red"}); // changes the fill of both circles
+    \*/
+    paperproto.set = function (itemsArray) {
+        !R.is(itemsArray, "array") && (itemsArray = Array.prototype.splice.call(arguments, 0, arguments.length));
+        var out = new Set(itemsArray);
+        this.__set__ && this.__set__.push(out);
+        out["paper"] = this;
+        out["type"] = "set";
+        return out;
+    };
+    /*\
+     * Paper.setStart
+     [ method ]
+     **
+     * Creates @Paper.set. All elements that will be created after calling this method and before calling
+     * @Paper.setFinish will be added to the set.
+     **
+     > Usage
+     | paper.setStart();
+     | paper.circle(10, 10, 5),
+     | paper.circle(30, 10, 5)
+     | var st = paper.setFinish();
+     | st.attr({fill: "red"}); // changes the fill of both circles
+    \*/
+    paperproto.setStart = function (set) {
+        this.__set__ = set || this.set();
+    };
+    /*\
+     * Paper.setFinish
+     [ method ]
+     **
+     * See @Paper.setStart. This method finishes catching and returns resulting set.
+     **
+     = (object) set
+    \*/
+    paperproto.setFinish = function (set) {
+        var out = this.__set__;
+        delete this.__set__;
+        return out;
+    };
+    /*\
+     * Paper.setSize
+     [ method ]
+     **
+     * If you need to change dimensions of the canvas call this method
+     **
+     > Parameters
+     **
+     - width (number) new width of the canvas
+     - height (number) new height of the canvas
+    \*/
+    paperproto.setSize = function (width, height) {
+        return R._engine.setSize.call(this, width, height);
+    };
+    /*\
+     * Paper.setViewBox
+     [ method ]
+     **
+     * Sets the view box of the paper. Practically it gives you ability to zoom and pan whole paper surface by 
+     * specifying new boundaries.
+     **
+     > Parameters
+     **
+     - x (number) new x position, default is `0`
+     - y (number) new y position, default is `0`
+     - w (number) new width of the canvas
+     - h (number) new height of the canvas
+     - fit (boolean) `true` if you want graphics to fit into new boundary box
+    \*/
+    paperproto.setViewBox = function (x, y, w, h, fit) {
+        return R._engine.setViewBox.call(this, x, y, w, h, fit);
+    };
+    /*\
+     * Paper.top
+     [ property ]
+     **
+     * Points to the topmost element on the paper
+    \*/
+    /*\
+     * Paper.bottom
+     [ property ]
+     **
+     * Points to the bottom element on the paper
+    \*/
+    paperproto.top = paperproto.bottom = null;
+    /*\
+     * Paper.raphael
+     [ property ]
+     **
+     * Points to the @Raphael object/function
+    \*/
+    paperproto.raphael = R;
+    var getOffset = function (elem) {
+        var box = elem.getBoundingClientRect(),
+            doc = elem.ownerDocument,
+            body = doc.body,
+            docElem = doc.documentElement,
+            clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
+            top  = box.top  + (g.win.pageYOffset || docElem.scrollTop || body.scrollTop ) - clientTop,
+            left = box.left + (g.win.pageXOffset || docElem.scrollLeft || body.scrollLeft) - clientLeft;
+        return {
+            y: top,
+            x: left
+        };
+    };
+    /*\
+     * Paper.getElementByPoint
+     [ method ]
+     **
+     * Returns you topmost element under given point.
+     **
+     = (object) Raphaël element object
+     > Parameters
+     **
+     - x (number) x coordinate from the top left corner of the window
+     - y (number) y coordinate from the top left corner of the window
+     > Usage
+     | paper.getElementByPoint(mouseX, mouseY).attr({stroke: "#f00"});
+    \*/
+    paperproto.getElementByPoint = function (x, y) {
+        var paper = this,
+            svg = paper.canvas,
+            target = g.doc.elementFromPoint(x, y);
+        if (g.win.opera && target.tagName == "svg") {
+            var so = getOffset(svg),
+                sr = svg.createSVGRect();
+            sr.x = x - so.x;
+            sr.y = y - so.y;
+            sr.width = sr.height = 1;
+            var hits = svg.getIntersectionList(sr, null);
+            if (hits.length) {
+                target = hits[hits.length - 1];
+            }
+        }
+        if (!target) {
+            return null;
+        }
+        while (target.parentNode && target != svg.parentNode && !target.raphael) {
+            target = target.parentNode;
+        }
+        target == paper.canvas.parentNode && (target = svg);
+        target = target && target.raphael ? paper.getById(target.raphaelid) : null;
+        return target;
+    };
+
+    /*\
+     * Paper.getElementsByBBox
+     [ method ]
+     **
+     * Returns set of elements that have an intersecting bounding box
+     **
+     > Parameters
+     **
+     - bbox (object) bbox to check with
+     = (object) @Set
+     \*/
+    paperproto.getElementsByBBox = function (bbox) {
+        var set = this.set();
+        this.forEach(function (el) {
+            if (R.isBBoxIntersect(el.getBBox(), bbox)) {
+                set.push(el);
+            }
+        });
+        return set;
+    };
+
+    /*\
+     * Paper.getById
+     [ method ]
+     **
+     * Returns you element by its internal ID.
+     **
+     > Parameters
+     **
+     - id (number) id
+     = (object) Raphaël element object
+    \*/
+    paperproto.getById = function (id) {
+        var bot = this.bottom;
+        while (bot) {
+            if (bot.id == id) {
+                return bot;
+            }
+            bot = bot.next;
+        }
+        return null;
+    };
+    /*\
+     * Paper.forEach
+     [ method ]
+     **
+     * Executes given function for each element on the paper
+     *
+     * If callback function returns `false` it will stop loop running.
+     **
+     > Parameters
+     **
+     - callback (function) function to run
+     - thisArg (object) context object for the callback
+     = (object) Paper object
+     > Usage
+     | paper.forEach(function (el) {
+     |     el.attr({ stroke: "blue" });
+     | });
+    \*/
+    paperproto.forEach = function (callback, thisArg) {
+        var bot = this.bottom;
+        while (bot) {
+            if (callback.call(thisArg, bot) === false) {
+                return this;
+            }
+            bot = bot.next;
+        }
+        return this;
+    };
+    /*\
+     * Paper.getElementsByPoint
+     [ method ]
+     **
+     * Returns set of elements that have common point inside
+     **
+     > Parameters
+     **
+     - x (number) x coordinate of the point
+     - y (number) y coordinate of the point
+     = (object) @Set
+    \*/
+    paperproto.getElementsByPoint = function (x, y) {
+        var set = this.set();
+        this.forEach(function (el) {
+            if (el.isPointInside(x, y)) {
+                set.push(el);
+            }
+        });
+        return set;
+    };
+    function x_y() {
+        return this.x + S + this.y;
+    }
+    function x_y_w_h() {
+        return this.x + S + this.y + S + this.width + " \xd7 " + this.height;
+    }
+    /*\
+     * Element.isPointInside
+     [ method ]
+     **
+     * Determine if given point is inside this element’s shape
+     **
+     > Parameters
+     **
+     - x (number) x coordinate of the point
+     - y (number) y coordinate of the point
+     = (boolean) `true` if point inside the shape
+    \*/
+    elproto.isPointInside = function (x, y) {
+        var rp = this.realPath = getPath[this.type](this);
+        if (this.attr('transform') && this.attr('transform').length) {
+            rp = R.transformPath(rp, this.attr('transform'));
+        }
+        return R.isPointInsidePath(rp, x, y);
+    };
+    /*\
+     * Element.getBBox
+     [ method ]
+     **
+     * Return bounding box for a given element
+     **
+     > Parameters
+     **
+     - isWithoutTransform (boolean) flag, `true` if you want to have bounding box before transformations. Default is `false`.
+     = (object) Bounding box object:
+     o {
+     o     x: (number) top left corner x
+     o     y: (number) top left corner y
+     o     x2: (number) bottom right corner x
+     o     y2: (number) bottom right corner y
+     o     width: (number) width
+     o     height: (number) height
+     o }
+    \*/
+    elproto.getBBox = function (isWithoutTransform) {
+        if (this.removed) {
+            return {};
+        }
+        var _ = this._;
+        if (isWithoutTransform) {
+            if (_.dirty || !_.bboxwt) {
+                this.realPath = getPath[this.type](this);
+                _.bboxwt = pathDimensions(this.realPath);
+                _.bboxwt.toString = x_y_w_h;
+                _.dirty = 0;
+            }
+            return _.bboxwt;
+        }
+        if (_.dirty || _.dirtyT || !_.bbox) {
+            if (_.dirty || !this.realPath) {
+                _.bboxwt = 0;
+                this.realPath = getPath[this.type](this);
+            }
+            _.bbox = pathDimensions(mapPath(this.realPath, this.matrix));
+            _.bbox.toString = x_y_w_h;
+            _.dirty = _.dirtyT = 0;
+        }
+        return _.bbox;
+    };
+    /*\
+     * Element.clone
+     [ method ]
+     **
+     = (object) clone of a given element
+     **
+    \*/
+    elproto.clone = function () {
+        if (this.removed) {
+            return null;
+        }
+        var out = this.paper[this.type]().attr(this.attr());
+        this.__set__ && this.__set__.push(out);
+        return out;
+    };
+    /*\
+     * Element.glow
+     [ method ]
+     **
+     * Return set of elements that create glow-like effect around given element. See @Paper.set.
+     *
+     * Note: Glow is not connected to the element. If you change element attributes it won’t adjust itself.
+     **
+     > Parameters
+     **
+     - glow (object) #optional parameters object with all properties optional:
+     o {
+     o     width (number) size of the glow, default is `10`
+     o     fill (boolean) will it be filled, default is `false`
+     o     opacity (number) opacity, default is `0.5`
+     o     offsetx (number) horizontal offset, default is `0`
+     o     offsety (number) vertical offset, default is `0`
+     o     color (string) glow colour, default is `black`
+     o }
+     = (object) @Paper.set of elements that represents glow
+    \*/
+    elproto.glow = function (glow) {
+        if (this.type == "text") {
+            return null;
+        }
+        glow = glow || {};
+        var s = {
+            width: (glow.width || 10) + (+this.attr("stroke-width") || 1),
+            fill: glow.fill || false,
+            opacity: glow.opacity || .5,
+            offsetx: glow.offsetx || 0,
+            offsety: glow.offsety || 0,
+            color: glow.color || "#000"
+        },
+            c = s.width / 2,
+            r = this.paper,
+            out = r.set(),
+            path = this.realPath || getPath[this.type](this);
+        path = this.matrix ? mapPath(path, this.matrix) : path;
+        for (var i = 1; i < c + 1; i++) {
+            out.push(r.path(path).attr({
+                stroke: s.color,
+                fill: s.fill ? s.color : "none",
+                "stroke-linejoin": "round",
+                "stroke-linecap": "round",
+                "stroke-width": +(s.width / c * i).toFixed(3),
+                opacity: +(s.opacity / c).toFixed(3)
+            }));
+        }
+        return out.insertBefore(this).translate(s.offsetx, s.offsety);
+    };
+    var curveslengths = {},
+    getPointAtSegmentLength = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length) {
+        if (length == null) {
+            return bezlen(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y);
+        } else {
+            return R.findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, getTatLen(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length));
+        }
+    },
+    getLengthFactory = function (istotal, subpath) {
+        return function (path, length, onlystart) {
+            path = path2curve(path);
+            var x, y, p, l, sp = "", subpaths = {}, point,
+                len = 0;
+            for (var i = 0, ii = path.length; i < ii; i++) {
+                p = path[i];
+                if (p[0] == "M") {
+                    x = +p[1];
+                    y = +p[2];
+                } else {
+                    l = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
+                    if (len + l > length) {
+                        if (subpath && !subpaths.start) {
+                            point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);
+                            sp += ["C" + point.start.x, point.start.y, point.m.x, point.m.y, point.x, point.y];
+                            if (onlystart) {return sp;}
+                            subpaths.start = sp;
+                            sp = ["M" + point.x, point.y + "C" + point.n.x, point.n.y, point.end.x, point.end.y, p[5], p[6]].join();
+                            len += l;
+                            x = +p[5];
+                            y = +p[6];
+                            continue;
+                        }
+                        if (!istotal && !subpath) {
+                            point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);
+                            return {x: point.x, y: point.y, alpha: point.alpha};
+                        }
+                    }
+                    len += l;
+                    x = +p[5];
+                    y = +p[6];
+                }
+                sp += p.shift() + p;
+            }
+            subpaths.end = sp;
+            point = istotal ? len : subpath ? subpaths : R.findDotsAtSegment(x, y, p[0], p[1], p[2], p[3], p[4], p[5], 1);
+            point.alpha && (point = {x: point.x, y: point.y, alpha: point.alpha});
+            return point;
+        };
+    };
+    var getTotalLength = getLengthFactory(1),
+        getPointAtLength = getLengthFactory(),
+        getSubpathsAtLength = getLengthFactory(0, 1);
+    /*\
+     * Raphael.getTotalLength
+     [ method ]
+     **
+     * Returns length of the given path in pixels.
+     **
+     > Parameters
+     **
+     - path (string) SVG path string.
+     **
+     = (number) length.
+    \*/
+    R.getTotalLength = getTotalLength;
+    /*\
+     * Raphael.getPointAtLength
+     [ method ]
+     **
+     * Return coordinates of the point located at the given length on the given path.
+     **
+     > Parameters
+     **
+     - path (string) SVG path string
+     - length (number)
+     **
+     = (object) representation of the point:
+     o {
+     o     x: (number) x coordinate
+     o     y: (number) y coordinate
+     o     alpha: (number) angle of derivative
+     o }
+    \*/
+    R.getPointAtLength = getPointAtLength;
+    /*\
+     * Raphael.getSubpath
+     [ method ]
+     **
+     * Return subpath of a given path from given length to given length.
+     **
+     > Parameters
+     **
+     - path (string) SVG path string
+     - from (number) position of the start of the segment
+     - to (number) position of the end of the segment
+     **
+     = (string) pathstring for the segment
+    \*/
+    R.getSubpath = function (path, from, to) {
+        if (this.getTotalLength(path) - to < 1e-6) {
+            return getSubpathsAtLength(path, from).end;
+        }
+        var a = getSubpathsAtLength(path, to, 1);
+        return from ? getSubpathsAtLength(a, from).end : a;
+    };
+    /*\
+     * Element.getTotalLength
+     [ method ]
+     **
+     * Returns length of the path in pixels. Only works for element of “path” type.
+     = (number) length.
+    \*/
+    elproto.getTotalLength = function () {
+        var path = this.getPath();
+        if (!path) {
+            return;
+        }
+
+        if (this.node.getTotalLength) {
+            return this.node.getTotalLength();
+        }
+
+        return getTotalLength(path);
+    };
+    /*\
+     * Element.getPointAtLength
+     [ method ]
+     **
+     * Return coordinates of the point located at the given length on the given path. Only works for element of “path” type.
+     **
+     > Parameters
+     **
+     - length (number)
+     **
+     = (object) representation of the point:
+     o {
+     o     x: (number) x coordinate
+     o     y: (number) y coordinate
+     o     alpha: (number) angle of derivative
+     o }
+    \*/
+    elproto.getPointAtLength = function (length) {
+        var path = this.getPath();
+        if (!path) {
+            return;
+        }
+
+        return getPointAtLength(path, length);
+    };
+    /*\
+     * Element.getPath
+     [ method ]
+     **
+     * Returns path of the element. Only works for elements of “path” type and simple elements like circle.
+     = (object) path
+     **
+    \*/
+    elproto.getPath = function () {
+        var path,
+            getPath = R._getPath[this.type];
+        
+        if (this.type == "text" || this.type == "set") {
+            return;
+        }
+
+        if (getPath) {
+            path = getPath(this);
+        }
+
+        return path;
+    };
+    /*\
+     * Element.getSubpath
+     [ method ]
+     **
+     * Return subpath of a given element from given length to given length. Only works for element of “path” type.
+     **
+     > Parameters
+     **
+     - from (number) position of the start of the segment
+     - to (number) position of the end of the segment
+     **
+     = (string) pathstring for the segment
+    \*/
+    elproto.getSubpath = function (from, to) {
+        var path = this.getPath();
+        if (!path) {
+            return;
+        }
+
+        return R.getSubpath(path, from, to);
+    };
+    /*\
+     * Raphael.easing_formulas
+     [ property ]
+     **
+     * Object that contains easing formulas for animation. You could extend it with your own. By default it has following list of easing:
+     # <ul>
+     #     <li>“linear”</li>
+     #     <li>“&lt;” or “easeIn” or “ease-in”</li>
+     #     <li>“>” or “easeOut” or “ease-out”</li>
+     #     <li>“&lt;>” or “easeInOut” or “ease-in-out”</li>
+     #     <li>“backIn” or “back-in”</li>
+     #     <li>“backOut” or “back-out”</li>
+     #     <li>“elastic”</li>
+     #     <li>“bounce”</li>
+     # </ul>
+     # <p>See also <a href="http://raphaeljs.com/easing.html">Easing demo</a>.</p>
+    \*/
+    var ef = R.easing_formulas = {
+        linear: function (n) {
+            return n;
+        },
+        "<": function (n) {
+            return pow(n, 1.7);
+        },
+        ">": function (n) {
+            return pow(n, .48);
+        },
+        "<>": function (n) {
+            var q = .48 - n / 1.04,
+                Q = math.sqrt(.1734 + q * q),
+                x = Q - q,
+                X = pow(abs(x), 1 / 3) * (x < 0 ? -1 : 1),
+                y = -Q - q,
+                Y = pow(abs(y), 1 / 3) * (y < 0 ? -1 : 1),
+                t = X + Y + .5;
+            return (1 - t) * 3 * t * t + t * t * t;
+        },
+        backIn: function (n) {
+            var s = 1.70158;
+            return n * n * ((s + 1) * n - s);
+        },
+        backOut: function (n) {
+            n = n - 1;
+            var s = 1.70158;
+            return n * n * ((s + 1) * n + s) + 1;
+        },
+        elastic: function (n) {
+            if (n == !!n) {
+                return n;
+            }
+            return pow(2, -10 * n) * math.sin((n - .075) * (2 * PI) / .3) + 1;
+        },
+        bounce: function (n) {
+            var s = 7.5625,
+                p = 2.75,
+                l;
+            if (n < (1 / p)) {
+                l = s * n * n;
+            } else {
+                if (n < (2 / p)) {
+                    n -= (1.5 / p);
+                    l = s * n * n + .75;
+                } else {
+                    if (n < (2.5 / p)) {
+                        n -= (2.25 / p);
+                        l = s * n * n + .9375;
+                    } else {
+                        n -= (2.625 / p);
+                        l = s * n * n + .984375;
+                    }
+                }
+            }
+            return l;
+        }
+    };
+    ef.easeIn = ef["ease-in"] = ef["<"];
+    ef.easeOut = ef["ease-out"] = ef[">"];
+    ef.easeInOut = ef["ease-in-out"] = ef["<>"];
+    ef["back-in"] = ef.backIn;
+    ef["back-out"] = ef.backOut;
+
+    var animationElements = [],
+        requestAnimFrame = window.requestAnimationFrame       ||
+                           window.webkitRequestAnimationFrame ||
+                           window.mozRequestAnimationFrame    ||
+                           window.oRequestAnimationFrame      ||
+                           window.msRequestAnimationFrame     ||
+                           function (callback) {
+                               setTimeout(callback, 16);
+                           },
+        animation = function () {
+            var Now = +new Date,
+                l = 0;
+            for (; l < animationElements.length; l++) {
+                var e = animationElements[l];
+                if (e.el.removed || e.paused) {
+                    continue;
+                }
+                var time = Now - e.start,
+                    ms = e.ms,
+                    easing = e.easing,
+                    from = e.from,
+                    diff = e.diff,
+                    to = e.to,
+                    t = e.t,
+                    that = e.el,
+                    set = {},
+                    now,
+                    init = {},
+                    key;
+                if (e.initstatus) {
+                    time = (e.initstatus * e.anim.top - e.prev) / (e.percent - e.prev) * ms;
+                    e.status = e.initstatus;
+                    delete e.initstatus;
+                    e.stop && animationElements.splice(l--, 1);
+                } else {
+                    e.status = (e.prev + (e.percent - e.prev) * (time / ms)) / e.anim.top;
+                }
+                if (time < 0) {
+                    continue;
+                }
+                if (time < ms) {
+                    var pos = easing(time / ms);
+                    for (var attr in from) if (from[has](attr)) {
+                        switch (availableAnimAttrs[attr]) {
+                            case nu:
+                                now = +from[attr] + pos * ms * diff[attr];
+                                break;
+                            case "colour":
+                                now = "rgb(" + [
+                                    upto255(round(from[attr].r + pos * ms * diff[attr].r)),
+                                    upto255(round(from[attr].g + pos * ms * diff[attr].g)),
+                                    upto255(round(from[attr].b + pos * ms * diff[attr].b))
+                                ].join(",") + ")";
+                                break;
+                            case "path":
+                                now = [];
+                                for (var i = 0, ii = from[attr].length; i < ii; i++) {
+                                    now[i] = [from[attr][i][0]];
+                                    for (var j = 1, jj = from[attr][i].length; j < jj; j++) {
+                                        now[i][j] = +from[attr][i][j] + pos * ms * diff[attr][i][j];
+                                    }
+                                    now[i] = now[i].join(S);
+                                }
+                                now = now.join(S);
+                                break;
+                            case "transform":
+                                if (diff[attr].real) {
+                                    now = [];
+                                    for (i = 0, ii = from[attr].length; i < ii; i++) {
+                                        now[i] = [from[attr][i][0]];
+                                        for (j = 1, jj = from[attr][i].length; j < jj; j++) {
+                                            now[i][j] = from[attr][i][j] + pos * ms * diff[attr][i][j];
+                                        }
+                                    }
+                                } else {
+                                    var get = function (i) {
+                                        return +from[attr][i] + pos * ms * diff[attr][i];
+                                    };
+                                    // now = [["r", get(2), 0, 0], ["t", get(3), get(4)], ["s", get(0), get(1), 0, 0]];
+                                    now = [["m", get(0), get(1), get(2), get(3), get(4), get(5)]];
+                                }
+                                break;
+                            case "csv":
+                                if (attr == "clip-rect") {
+                                    now = [];
+                                    i = 4;
+                                    while (i--) {
+                                        now[i] = +from[attr][i] + pos * ms * diff[attr][i];
+                                    }
+                                }
+                                break;
+                            default:
+                                var from2 = [][concat](from[attr]);
+                                now = [];
+                                i = that.paper.customAttributes[attr].length;
+                                while (i--) {
+                                    now[i] = +from2[i] + pos * ms * diff[attr][i];
+                                }
+                                break;
+                        }
+                        set[attr] = now;
+                    }
+                    that.attr(set);
+                    (function (id, that, anim) {
+                        setTimeout(function () {
+                            eve("raphael.anim.frame." + id, that, anim);
+                        });
+                    })(that.id, that, e.anim);
+                } else {
+                    (function(f, el, a) {
+                        setTimeout(function() {
+                            eve("raphael.anim.frame." + el.id, el, a);
+                            eve("raphael.anim.finish." + el.id, el, a);
+                            R.is(f, "function") && f.call(el);
+                        });
+                    })(e.callback, that, e.anim);
+                    that.attr(to);
+                    animationElements.splice(l--, 1);
+                    if (e.repeat > 1 && !e.next) {
+                        for (key in to) if (to[has](key)) {
+                            init[key] = e.totalOrigin[key];
+                        }
+                        e.el.attr(init);
+                        runAnimation(e.anim, e.el, e.anim.percents[0], null, e.totalOrigin, e.repeat - 1);
+                    }
+                    if (e.next && !e.stop) {
+                        runAnimation(e.anim, e.el, e.next, null, e.totalOrigin, e.repeat);
+                    }
+                }
+            }
+            R.svg && that && that.paper && that.paper.safari();
+            animationElements.length && requestAnimFrame(animation);
+        },
+        upto255 = function (color) {
+            return color > 255 ? 255 : color < 0 ? 0 : color;
+        };
+    /*\
+     * Element.animateWith
+     [ method ]
+     **
+     * Acts similar to @Element.animate, but ensure that given animation runs in sync with another given element.
+     **
+     > Parameters
+     **
+     - el (object) element to sync with
+     - anim (object) animation to sync with
+     - params (object) #optional final attributes for the element, see also @Element.attr
+     - ms (number) #optional number of milliseconds for animation to run
+     - easing (string) #optional easing type. Accept on of @Raphael.easing_formulas or CSS format: `cubic&#x2010;bezier(XX,&#160;XX,&#160;XX,&#160;XX)`
+     - callback (function) #optional callback function. Will be called at the end of animation.
+     * or
+     - element (object) element to sync with
+     - anim (object) animation to sync with
+     - animation (object) #optional animation object, see @Raphael.animation
+     **
+     = (object) original element
+    \*/
+    elproto.animateWith = function (el, anim, params, ms, easing, callback) {
+        var element = this;
+        if (element.removed) {
+            callback && callback.call(element);
+            return element;
+        }
+        var a = params instanceof Animation ? params : R.animation(params, ms, easing, callback),
+            x, y;
+        runAnimation(a, element, a.percents[0], null, element.attr());
+        for (var i = 0, ii = animationElements.length; i < ii; i++) {
+            if (animationElements[i].anim == anim && animationElements[i].el == el) {
+                animationElements[ii - 1].start = animationElements[i].start;
+                break;
+            }
+        }
+        return element;
+        // 
+        // 
+        // var a = params ? R.animation(params, ms, easing, callback) : anim,
+        //     status = element.status(anim);
+        // return this.animate(a).status(a, status * anim.ms / a.ms);
+    };
+    function CubicBezierAtTime(t, p1x, p1y, p2x, p2y, duration) {
+        var cx = 3 * p1x,
+            bx = 3 * (p2x - p1x) - cx,
+            ax = 1 - cx - bx,
+            cy = 3 * p1y,
+            by = 3 * (p2y - p1y) - cy,
+            ay = 1 - cy - by;
+        function sampleCurveX(t) {
+            return ((ax * t + bx) * t + cx) * t;
+        }
+        function solve(x, epsilon) {
+            var t = solveCurveX(x, epsilon);
+            return ((ay * t + by) * t + cy) * t;
+        }
+        function solveCurveX(x, epsilon) {
+            var t0, t1, t2, x2, d2, i;
+            for(t2 = x, i = 0; i < 8; i++) {
+                x2 = sampleCurveX(t2) - x;
+                if (abs(x2) < epsilon) {
+                    return t2;
+                }
+                d2 = (3 * ax * t2 + 2 * bx) * t2 + cx;
+                if (abs(d2) < 1e-6) {
+                    break;
+                }
+                t2 = t2 - x2 / d2;
+            }
+            t0 = 0;
+            t1 = 1;
+            t2 = x;
+            if (t2 < t0) {
+                return t0;
+            }
+            if (t2 > t1) {
+                return t1;
+            }
+            while (t0 < t1) {
+                x2 = sampleCurveX(t2);
+                if (abs(x2 - x) < epsilon) {
+                    return t2;
+                }
+                if (x > x2) {
+                    t0 = t2;
+                } else {
+                    t1 = t2;
+                }
+                t2 = (t1 - t0) / 2 + t0;
+            }
+            return t2;
+        }
+        return solve(t, 1 / (200 * duration));
+    }
+    elproto.onAnimation = function (f) {
+        f ? eve.on("raphael.anim.frame." + this.id, f) : eve.unbind("raphael.anim.frame." + this.id);
+        return this;
+    };
+    function Animation(anim, ms) {
+        var percents = [],
+            newAnim = {};
+        this.ms = ms;
+        this.times = 1;
+        if (anim) {
+            for (var attr in anim) if (anim[has](attr)) {
+                newAnim[toFloat(attr)] = anim[attr];
+                percents.push(toFloat(attr));
+            }
+            percents.sort(sortByNumber);
+        }
+        this.anim = newAnim;
+        this.top = percents[percents.length - 1];
+        this.percents = percents;
+    }
+    /*\
+     * Animation.delay
+     [ method ]
+     **
+     * Creates a copy of existing animation object with given delay.
+     **
+     > Parameters
+     **
+     - delay (number) number of ms to pass between animation start and actual animation
+     **
+     = (object) new altered Animation object
+     | var anim = Raphael.animation({cx: 10, cy: 20}, 2e3);
+     | circle1.animate(anim); // run the given animation immediately
+     | circle2.animate(anim.delay(500)); // run the given animation after 500 ms
+    \*/
+    Animation.prototype.delay = function (delay) {
+        var a = new Animation(this.anim, this.ms);
+        a.times = this.times;
+        a.del = +delay || 0;
+        return a;
+    };
+    /*\
+     * Animation.repeat
+     [ method ]
+     **
+     * Creates a copy of existing animation object with given repetition.
+     **
+     > Parameters
+     **
+     - repeat (number) number iterations of animation. For infinite animation pass `Infinity`
+     **
+     = (object) new altered Animation object
+    \*/
+    Animation.prototype.repeat = function (times) {
+        var a = new Animation(this.anim, this.ms);
+        a.del = this.del;
+        a.times = math.floor(mmax(times, 0)) || 1;
+        return a;
+    };
+    function runAnimation(anim, element, percent, status, totalOrigin, times) {
+        percent = toFloat(percent);
+        var params,
+            isInAnim,
+            isInAnimSet,
+            percents = [],
+            next,
+            prev,
+            timestamp,
+            ms = anim.ms,
+            from = {},
+            to = {},
+            diff = {};
+        if (status) {
+            for (i = 0, ii = animationElements.length; i < ii; i++) {
+                var e = animationElements[i];
+                if (e.el.id == element.id && e.anim == anim) {
+                    if (e.percent != percent) {
+                        animationElements.splice(i, 1);
+                        isInAnimSet = 1;
+                    } else {
+                        isInAnim = e;
+                    }
+                    element.attr(e.totalOrigin);
+                    break;
+                }
+            }
+        } else {
+            status = +to; // NaN
+        }
+        for (var i = 0, ii = anim.percents.length; i < ii; i++) {
+            if (anim.percents[i] == percent || anim.percents[i] > status * anim.top) {
+                percent = anim.percents[i];
+                prev = anim.percents[i - 1] || 0;
+                ms = ms / anim.top * (percent - prev);
+                next = anim.percents[i + 1];
+                params = anim.anim[percent];
+                break;
+            } else if (status) {
+                element.attr(anim.anim[anim.percents[i]]);
+            }
+        }
+        if (!params) {
+            return;
+        }
+        if (!isInAnim) {
+            for (var attr in params) if (params[has](attr)) {
+                if (availableAnimAttrs[has](attr) || element.paper.customAttributes[has](attr)) {
+                    from[attr] = element.attr(attr);
+                    (from[attr] == null) && (from[attr] = availableAttrs[attr]);
+                    to[attr] = params[attr];
+                    switch (availableAnimAttrs[attr]) {
+                        case nu:
+                            diff[attr] = (to[attr] - from[attr]) / ms;
+                            break;
+                        case "colour":
+                            from[attr] = R.getRGB(from[attr]);
+                            var toColour = R.getRGB(to[attr]);
+                            diff[attr] = {
+                                r: (toColour.r - from[attr].r) / ms,
+                                g: (toColour.g - from[attr].g) / ms,
+                                b: (toColour.b - from[attr].b) / ms
+                            };
+                            break;
+                        case "path":
+                            var pathes = path2curve(from[attr], to[attr]),
+                                toPath = pathes[1];
+                            from[attr] = pathes[0];
+                            diff[attr] = [];
+                            for (i = 0, ii = from[attr].length; i < ii; i++) {
+                                diff[attr][i] = [0];
+                                for (var j = 1, jj = from[attr][i].length; j < jj; j++) {
+                                    diff[attr][i][j] = (toPath[i][j] - from[attr][i][j]) / ms;
+                                }
+                            }
+                            break;
+                        case "transform":
+                            var _ = element._,
+                                eq = equaliseTransform(_[attr], to[attr]);
+                            if (eq) {
+                                from[attr] = eq.from;
+                                to[attr] = eq.to;
+                                diff[attr] = [];
+                                diff[attr].real = true;
+                                for (i = 0, ii = from[attr].length; i < ii; i++) {
+                                    diff[attr][i] = [from[attr][i][0]];
+                                    for (j = 1, jj = from[attr][i].length; j < jj; j++) {
+                                        diff[attr][i][j] = (to[attr][i][j] - from[attr][i][j]) / ms;
+                                    }
+                                }
+                            } else {
+                                var m = (element.matrix || new Matrix),
+                                    to2 = {
+                                        _: {transform: _.transform},
+                                        getBBox: function () {
+                                            return element.getBBox(1);
+                                        }
+                                    };
+                                from[attr] = [
+                                    m.a,
+                                    m.b,
+                                    m.c,
+                                    m.d,
+                                    m.e,
+                                    m.f
+                                ];
+                                extractTransform(to2, to[attr]);
+                                to[attr] = to2._.transform;
+                                diff[attr] = [
+                                    (to2.matrix.a - m.a) / ms,
+                                    (to2.matrix.b - m.b) / ms,
+                                    (to2.matrix.c - m.c) / ms,
+                                    (to2.matrix.d - m.d) / ms,
+                                    (to2.matrix.e - m.e) / ms,
+                                    (to2.matrix.f - m.f) / ms
+                                ];
+                                // from[attr] = [_.sx, _.sy, _.deg, _.dx, _.dy];
+                                // var to2 = {_:{}, getBBox: function () { return element.getBBox(); }};
+                                // extractTransform(to2, to[attr]);
+                                // diff[attr] = [
+                                //     (to2._.sx - _.sx) / ms,
+                                //     (to2._.sy - _.sy) / ms,
+                                //     (to2._.deg - _.deg) / ms,
+                                //     (to2._.dx - _.dx) / ms,
+                                //     (to2._.dy - _.dy) / ms
+                                // ];
+                            }
+                            break;
+                        case "csv":
+                            var values = Str(params[attr])[split](separator),
+                                from2 = Str(from[attr])[split](separator);
+                            if (attr == "clip-rect") {
+                                from[attr] = from2;
+                                diff[attr] = [];
+                                i = from2.length;
+                                while (i--) {
+                                    diff[attr][i] = (values[i] - from[attr][i]) / ms;
+                                }
+                            }
+                            to[attr] = values;
+                            break;
+                        default:
+                            values = [][concat](params[attr]);
+                            from2 = [][concat](from[attr]);
+                            diff[attr] = [];
+                            i = element.paper.customAttributes[attr].length;
+                            while (i--) {
+                                diff[attr][i] = ((values[i] || 0) - (from2[i] || 0)) / ms;
+                            }
+                            break;
+                    }
+                }
+            }
+            var easing = params.easing,
+                easyeasy = R.easing_formulas[easing];
+            if (!easyeasy) {
+                easyeasy = Str(easing).match(bezierrg);
+                if (easyeasy && easyeasy.length == 5) {
+                    var curve = easyeasy;
+                    easyeasy = function (t) {
+                        return CubicBezierAtTime(t, +curve[1], +curve[2], +curve[3], +curve[4], ms);
+                    };
+                } else {
+                    easyeasy = pipe;
+                }
+            }
+            timestamp = params.start || anim.start || +new Date;
+            e = {
+                anim: anim,
+                percent: percent,
+                timestamp: timestamp,
+                start: timestamp + (anim.del || 0),
+                status: 0,
+                initstatus: status || 0,
+                stop: false,
+                ms: ms,
+                easing: easyeasy,
+                from: from,
+                diff: diff,
+                to: to,
+                el: element,
+                callback: params.callback,
+                prev: prev,
+                next: next,
+                repeat: times || anim.times,
+                origin: element.attr(),
+                totalOrigin: totalOrigin
+            };
+            animationElements.push(e);
+            if (status && !isInAnim && !isInAnimSet) {
+                e.stop = true;
+                e.start = new Date - ms * status;
+                if (animationElements.length == 1) {
+                    return animation();
+                }
+            }
+            if (isInAnimSet) {
+                e.start = new Date - e.ms * status;
+            }
+            animationElements.length == 1 && requestAnimFrame(animation);
+        } else {
+            isInAnim.initstatus = status;
+            isInAnim.start = new Date - isInAnim.ms * status;
+        }
+        eve("raphael.anim.start." + element.id, element, anim);
+    }
+    /*\
+     * Raphael.animation
+     [ method ]
+     **
+     * Creates an animation object that can be passed to the @Element.animate or @Element.animateWith methods.
+     * See also @Animation.delay and @Animation.repeat methods.
+     **
+     > Parameters
+     **
+     - params (object) final attributes for the element, see also @Element.attr
+     - ms (number) number of milliseconds for animation to run
+     - easing (string) #optional easing type. Accept one of @Raphael.easing_formulas or CSS format: `cubic&#x2010;bezier(XX,&#160;XX,&#160;XX,&#160;XX)`
+     - callback (function) #optional callback function. Will be called at the end of animation.
+     **
+     = (object) @Animation
+    \*/
+    R.animation = function (params, ms, easing, callback) {
+        if (params instanceof Animation) {
+            return params;
+        }
+        if (R.is(easing, "function") || !easing) {
+            callback = callback || easing || null;
+            easing = null;
+        }
+        params = Object(params);
+        ms = +ms || 0;
+        var p = {},
+            json,
+            attr;
+        for (attr in params) if (params[has](attr) && toFloat(attr) != attr && toFloat(attr) + "%" != attr) {
+            json = true;
+            p[attr] = params[attr];
+        }
+        if (!json) {
+            return new Animation(params, ms);
+        } else {
+            easing && (p.easing = easing);
+            callback && (p.callback = callback);
+            return new Animation({100: p}, ms);
+        }
+    };
+    /*\
+     * Element.animate
+     [ method ]
+     **
+     * Creates and starts animation for given element.
+     **
+     > Parameters
+     **
+     - params (object) final attributes for the element, see also @Element.attr
+     - ms (number) number of milliseconds for animation to run
+     - easing (string) #optional easing type. Accept one of @Raphael.easing_formulas or CSS format: `cubic&#x2010;bezier(XX,&#160;XX,&#160;XX,&#160;XX)`
+     - callback (function) #optional callback function. Will be called at the end of animation.
+     * or
+     - animation (object) animation object, see @Raphael.animation
+     **
+     = (object) original element
+    \*/
+    elproto.animate = function (params, ms, easing, callback) {
+        var element = this;
+        if (element.removed) {
+            callback && callback.call(element);
+            return element;
+        }
+        var anim = params instanceof Animation ? params : R.animation(params, ms, easing, callback);
+        runAnimation(anim, element, anim.percents[0], null, element.attr());
+        return element;
+    };
+    /*\
+     * Element.setTime
+     [ method ]
+     **
+     * Sets the status of animation of the element in milliseconds. Similar to @Element.status method.
+     **
+     > Parameters
+     **
+     - anim (object) animation object
+     - value (number) number of milliseconds from the beginning of the animation
+     **
+     = (object) original element if `value` is specified
+     * Note, that during animation following events are triggered:
+     *
+     * On each animation frame event `anim.frame.<id>`, on start `anim.start.<id>` and on end `anim.finish.<id>`.
+    \*/
+    elproto.setTime = function (anim, value) {
+        if (anim && value != null) {
+            this.status(anim, mmin(value, anim.ms) / anim.ms);
+        }
+        return this;
+    };
+    /*\
+     * Element.status
+     [ method ]
+     **
+     * Gets or sets the status of animation of the element.
+     **
+     > Parameters
+     **
+     - anim (object) #optional animation object
+     - value (number) #optional 0 – 1. If specified, method works like a setter and sets the status of a given animation to the value. This will cause animation to jump to the given position.
+     **
+     = (number) status
+     * or
+     = (array) status if `anim` is not specified. Array of objects in format:
+     o {
+     o     anim: (object) animation object
+     o     status: (number) status
+     o }
+     * or
+     = (object) original element if `value` is specified
+    \*/
+    elproto.status = function (anim, value) {
+        var out = [],
+            i = 0,
+            len,
+            e;
+        if (value != null) {
+            runAnimation(anim, this, -1, mmin(value, 1));
+            return this;
+        } else {
+            len = animationElements.length;
+            for (; i < len; i++) {
+                e = animationElements[i];
+                if (e.el.id == this.id && (!anim || e.anim == anim)) {
+                    if (anim) {
+                        return e.status;
+                    }
+                    out.push({
+                        anim: e.anim,
+                        status: e.status
+                    });
+                }
+            }
+            if (anim) {
+                return 0;
+            }
+            return out;
+        }
+    };
+    /*\
+     * Element.pause
+     [ method ]
+     **
+     * Stops animation of the element with ability to resume it later on.
+     **
+     > Parameters
+     **
+     - anim (object) #optional animation object
+     **
+     = (object) original element
+    \*/
+    elproto.pause = function (anim) {
+        for (var i = 0; i < animationElements.length; i++) if (animationElements[i].el.id == this.id && (!anim || animationElements[i].anim == anim)) {
+            if (eve("raphael.anim.pause." + this.id, this, animationElements[i].anim) !== false) {
+                animationElements[i].paused = true;
+            }
+        }
+        return this;
+    };
+    /*\
+     * Element.resume
+     [ method ]
+     **
+     * Resumes animation if it was paused with @Element.pause method.
+     **
+     > Parameters
+     **
+     - anim (object) #optional animation object
+     **
+     = (object) original element
+    \*/
+    elproto.resume = function (anim) {
+        for (var i = 0; i < animationElements.length; i++) if (animationElements[i].el.id == this.id && (!anim || animationElements[i].anim == anim)) {
+            var e = animationElements[i];
+            if (eve("raphael.anim.resume." + this.id, this, e.anim) !== false) {
+                delete e.paused;
+                this.status(e.anim, e.status);
+            }
+        }
+        return this;
+    };
+    /*\
+     * Element.stop
+     [ method ]
+     **
+     * Stops animation of the element.
+     **
+     > Parameters
+     **
+     - anim (object) #optional animation object
+     **
+     = (object) original element
+    \*/
+    elproto.stop = function (anim) {
+        for (var i = 0; i < animationElements.length; i++) if (animationElements[i].el.id == this.id && (!anim || animationElements[i].anim == anim)) {
+            if (eve("raphael.anim.stop." + this.id, this, animationElements[i].anim) !== false) {
+                animationElements.splice(i--, 1);
+            }
+        }
+        return this;
+    };
+    function stopAnimation(paper) {
+        for (var i = 0; i < animationElements.length; i++) if (animationElements[i].el.paper == paper) {
+            animationElements.splice(i--, 1);
+        }
+    }
+    eve.on("raphael.remove", stopAnimation);
+    eve.on("raphael.clear", stopAnimation);
+    elproto.toString = function () {
+        return "Rapha\xebl\u2019s object";
+    };
+
+    // Set
+    var Set = function (items) {
+        this.items = [];
+        this.length = 0;
+        this.type = "set";
+        if (items) {
+            for (var i = 0, ii = items.length; i < ii; i++) {
+                if (items[i] && (items[i].constructor == elproto.constructor || items[i].constructor == Set)) {
+                    this[this.items.length] = this.items[this.items.length] = items[i];
+                    this.length++;
+                }
+            }
+        }
+    },
+    setproto = Set.prototype;
+    /*\
+     * Set.push
+     [ method ]
+     **
+     * Adds each argument to the current set.
+     = (object) original element
+    \*/
+    setproto.push = function () {
+        var item,
+            len;
+        for (var i = 0, ii = arguments.length; i < ii; i++) {
+            item = arguments[i];
+            if (item && (item.constructor == elproto.constructor || item.constructor == Set)) {
+                len = this.items.length;
+                this[len] = this.items[len] = item;
+                this.length++;
+            }
+        }
+        return this;
+    };
+    /*\
+     * Set.pop
+     [ method ]
+     **
+     * Removes last element and returns it.
+     = (object) element
+    \*/
+    setproto.pop = function () {
+        this.length && delete this[this.length--];
+        return this.items.pop();
+    };
+    /*\
+     * Set.forEach
+     [ method ]
+     **
+     * Executes given function for each element in the set.
+     *
+     * If function returns `false` it will stop loop running.
+     **
+     > Parameters
+     **
+     - callback (function) function to run
+     - thisArg (object) context object for the callback
+     = (object) Set object
+    \*/
+    setproto.forEach = function (callback, thisArg) {
+        for (var i = 0, ii = this.items.length; i < ii; i++) {
+            if (callback.call(thisArg, this.items[i], i) === false) {
+                return this;
+            }
+        }
+        return this;
+    };
+    for (var method in elproto) if (elproto[has](method)) {
+        setproto[method] = (function (methodname) {
+            return function () {
+                var arg = arguments;
+                return this.forEach(function (el) {
+                    el[methodname][apply](el, arg);
+                });
+            };
+        })(method);
+    }
+    setproto.attr = function (name, value) {
+        if (name && R.is(name, array) && R.is(name[0], "object")) {
+            for (var j = 0, jj = name.length; j < jj; j++) {
+                this.items[j].attr(name[j]);
+            }
+        } else {
+            for (var i = 0, ii = this.items.length; i < ii; i++) {
+                this.items[i].attr(name, value);
+            }
+        }
+        return this;
+    };
+    /*\
+     * Set.clear
+     [ method ]
+     **
+     * Removeds all elements from the set
+    \*/
+    setproto.clear = function () {
+        while (this.length) {
+            this.pop();
+        }
+    };
+    /*\
+     * Set.splice
+     [ method ]
+     **
+     * Removes given element from the set
+     **
+     > Parameters
+     **
+     - index (number) position of the deletion
+     - count (number) number of element to remove
+     - insertion… (object) #optional elements to insert
+     = (object) set elements that were deleted
+    \*/
+    setproto.splice = function (index, count, insertion) {
+        index = index < 0 ? mmax(this.length + index, 0) : index;
+        count = mmax(0, mmin(this.length - index, count));
+        var tail = [],
+            todel = [],
+            args = [],
+            i;
+        for (i = 2; i < arguments.length; i++) {
+            args.push(arguments[i]);
+        }
+        for (i = 0; i < count; i++) {
+            todel.push(this[index + i]);
+        }
+        for (; i < this.length - index; i++) {
+            tail.push(this[index + i]);
+        }
+        var arglen = args.length;
+        for (i = 0; i < arglen + tail.length; i++) {
+            this.items[index + i] = this[index + i] = i < arglen ? args[i] : tail[i - arglen];
+        }
+        i = this.items.length = this.length -= count - arglen;
+        while (this[i]) {
+            delete this[i++];
+        }
+        return new Set(todel);
+    };
+    /*\
+     * Set.exclude
+     [ method ]
+     **
+     * Removes given element from the set
+     **
+     > Parameters
+     **
+     - element (object) element to remove
+     = (boolean) `true` if object was found & removed from the set
+    \*/
+    setproto.exclude = function (el) {
+        for (var i = 0, ii = this.length; i < ii; i++) if (this[i] == el) {
+            this.splice(i, 1);
+            return true;
+        }
+    };
+    setproto.animate = function (params, ms, easing, callback) {
+        (R.is(easing, "function") || !easing) && (callback = easing || null);
+        var len = this.items.length,
+            i = len,
+            item,
+            set = this,
+            collector;
+        if (!len) {
+            return this;
+        }
+        callback && (collector = function () {
+            !--len && callback.call(set);
+        });
+        easing = R.is(easing, string) ? easing : collector;
+        var anim = R.animation(params, ms, easing, collector);
+        item = this.items[--i].animate(anim);
+        while (i--) {
+            this.items[i] && !this.items[i].removed && this.items[i].animateWith(item, anim, anim);
+            (this.items[i] && !this.items[i].removed) || len--;
+        }
+        return this;
+    };
+    setproto.insertAfter = function (el) {
+        var i = this.items.length;
+        while (i--) {
+            this.items[i].insertAfter(el);
+        }
+        return this;
+    };
+    setproto.getBBox = function () {
+        var x = [],
+            y = [],
+            x2 = [],
+            y2 = [];
+        for (var i = this.items.length; i--;) if (!this.items[i].removed) {
+            var box = this.items[i].getBBox();
+            x.push(box.x);
+            y.push(box.y);
+            x2.push(box.x + box.width);
+            y2.push(box.y + box.height);
+        }
+        x = mmin[apply](0, x);
+        y = mmin[apply](0, y);
+        x2 = mmax[apply](0, x2);
+        y2 = mmax[apply](0, y2);
+        return {
+            x: x,
+            y: y,
+            x2: x2,
+            y2: y2,
+            width: x2 - x,
+            height: y2 - y
+        };
+    };
+    setproto.clone = function (s) {
+        s = this.paper.set();
+        for (var i = 0, ii = this.items.length; i < ii; i++) {
+            s.push(this.items[i].clone());
+        }
+        return s;
+    };
+    setproto.toString = function () {
+        return "Rapha\xebl\u2018s set";
+    };
+
+    setproto.glow = function(glowConfig) {
+        var ret = this.paper.set();
+        this.forEach(function(shape, index){
+            var g = shape.glow(glowConfig);
+            if(g != null){
+                g.forEach(function(shape2, index2){
+                    ret.push(shape2);
+                });
+            }
+        });
+        return ret;
+    };
+
+
+    /*\
+     * Set.isPointInside
+     [ method ]
+     **
+     * Determine if given point is inside this set’s elements
+     **
+     > Parameters
+     **
+     - x (number) x coordinate of the point
+     - y (number) y coordinate of the point
+     = (boolean) `true` if point is inside any of the set's elements
+     \*/
+    setproto.isPointInside = function (x, y) {
+        var isPointInside = false;
+        this.forEach(function (el) {
+            if (el.isPointInside(x, y)) {
+                isPointInside = true;
+                return false; // stop loop
+            }
+        });
+        return isPointInside;
+    };
+
+    /*\
+     * Raphael.registerFont
+     [ method ]
+     **
+     * Adds given font to the registered set of fonts for Raphaël. Should be used as an internal call from within Cufón’s font file.
+     * Returns original parameter, so it could be used with chaining.
+     # <a href="http://wiki.github.com/sorccu/cufon/about">More about Cufón and how to convert your font form TTF, OTF, etc to JavaScript file.</a>
+     **
+     > Parameters
+     **
+     - font (object) the font to register
+     = (object) the font you passed in
+     > Usage
+     | Cufon.registerFont(Raphael.registerFont({…}));
+    \*/
+    R.registerFont = function (font) {
+        if (!font.face) {
+            return font;
+        }
+        this.fonts = this.fonts || {};
+        var fontcopy = {
+                w: font.w,
+                face: {},
+                glyphs: {}
+            },
+            family = font.face["font-family"];
+        for (var prop in font.face) if (font.face[has](prop)) {
+            fontcopy.face[prop] = font.face[prop];
+        }
+        if (this.fonts[family]) {
+            this.fonts[family].push(fontcopy);
+        } else {
+            this.fonts[family] = [fontcopy];
+        }
+        if (!font.svg) {
+            fontcopy.face["units-per-em"] = toInt(font.face["units-per-em"], 10);
+            for (var glyph in font.glyphs) if (font.glyphs[has](glyph)) {
+                var path = font.glyphs[glyph];
+                fontcopy.glyphs[glyph] = {
+                    w: path.w,
+                    k: {},
+                    d: path.d && "M" + path.d.replace(/[mlcxtrv]/g, function (command) {
+                            return {l: "L", c: "C", x: "z", t: "m", r: "l", v: "c"}[command] || "M";
+                        }) + "z"
+                };
+                if (path.k) {
+                    for (var k in path.k) if (path[has](k)) {
+                        fontcopy.glyphs[glyph].k[k] = path.k[k];
+                    }
+                }
+            }
+        }
+        return font;
+    };
+    /*\
+     * Paper.getFont
+     [ method ]
+     **
+     * Finds font object in the registered fonts by given parameters. You could specify only one word from the font name, like “Myriad” for “Myriad Pro”.
+     **
+     > Parameters
+     **
+     - family (string) font family name or any word from it
+     - weight (string) #optional font weight
+     - style (string) #optional font style
+     - stretch (string) #optional font stretch
+     = (object) the font object
+     > Usage
+     | paper.print(100, 100, "Test string", paper.getFont("Times", 800), 30);
+    \*/
+    paperproto.getFont = function (family, weight, style, stretch) {
+        stretch = stretch || "normal";
+        style = style || "normal";
+        weight = +weight || {normal: 400, bold: 700, lighter: 300, bolder: 800}[weight] || 400;
+        if (!R.fonts) {
+            return;
+        }
+        var font = R.fonts[family];
+        if (!font) {
+            var name = new RegExp("(^|\\s)" + family.replace(/[^\w\d\s+!~.:_-]/g, E) + "(\\s|$)", "i");
+            for (var fontName in R.fonts) if (R.fonts[has](fontName)) {
+                if (name.test(fontName)) {
+                    font = R.fonts[fontName];
+                    break;
+                }
+            }
+        }
+        var thefont;
+        if (font) {
+            for (var i = 0, ii = font.length; i < ii; i++) {
+                thefont = font[i];
+                if (thefont.face["font-weight"] == weight && (thefont.face["font-style"] == style || !thefont.face["font-style"]) && thefont.face["font-stretch"] == stretch) {
+                    break;
+                }
+            }
+        }
+        return thefont;
+    };
+    /*\
+     * Paper.print
+     [ method ]
+     **
+     * Creates path that represent given text written using given font at given position with given size.
+     * Result of the method is path element that contains whole text as a separate path.
+     **
+     > Parameters
+     **
+     - x (number) x position of the text
+     - y (number) y position of the text
+     - string (string) text to print
+     - font (object) font object, see @Paper.getFont
+     - size (number) #optional size of the font, default is `16`
+     - origin (string) #optional could be `"baseline"` or `"middle"`, default is `"middle"`
+     - letter_spacing (number) #optional number in range `-1..1`, default is `0`
+     - line_spacing (number) #optional number in range `1..3`, default is `1`
+     = (object) resulting path element, which consist of all letters
+     > Usage
+     | var txt = r.print(10, 50, "print", r.getFont("Museo"), 30).attr({fill: "#fff"});
+    \*/
+    paperproto.print = function (x, y, string, font, size, origin, letter_spacing, line_spacing) {
+        origin = origin || "middle"; // baseline|middle
+        letter_spacing = mmax(mmin(letter_spacing || 0, 1), -1);
+        line_spacing = mmax(mmin(line_spacing || 1, 3), 1);
+        var letters = Str(string)[split](E),
+            shift = 0,
+            notfirst = 0,
+            path = E,
+            scale;
+        R.is(font, "string") && (font = this.getFont(font));
+        if (font) {
+            scale = (size || 16) / font.face["units-per-em"];
+            var bb = font.face.bbox[split](separator),
+                top = +bb[0],
+                lineHeight = bb[3] - bb[1],
+                shifty = 0,
+                height = +bb[1] + (origin == "baseline" ? lineHeight + (+font.face.descent) : lineHeight / 2);
+            for (var i = 0, ii = letters.length; i < ii; i++) {
+                if (letters[i] == "\n") {
+                    shift = 0;
+                    curr = 0;
+                    notfirst = 0;
+                    shifty += lineHeight * line_spacing;
+                } else {
+                    var prev = notfirst && font.glyphs[letters[i - 1]] || {},
+                        curr = font.glyphs[letters[i]];
+                    shift += notfirst ? (prev.w || font.w) + (prev.k && prev.k[letters[i]] || 0) + (font.w * letter_spacing) : 0;
+                    notfirst = 1;
+                }
+                if (curr && curr.d) {
+                    path += R.transformPath(curr.d, ["t", shift * scale, shifty * scale, "s", scale, scale, top, height, "t", (x - top) / scale, (y - height) / scale]);
+                }
+            }
+        }
+        return this.path(path).attr({
+            fill: "#000",
+            stroke: "none"
+        });
+    };
+
+    /*\
+     * Paper.add
+     [ method ]
+     **
+     * Imports elements in JSON array in format `{type: type, <attributes>}`
+     **
+     > Parameters
+     **
+     - json (array)
+     = (object) resulting set of imported elements
+     > Usage
+     | paper.add([
+     |     {
+     |         type: "circle",
+     |         cx: 10,
+     |         cy: 10,
+     |         r: 5
+     |     },
+     |     {
+     |         type: "rect",
+     |         x: 10,
+     |         y: 10,
+     |         width: 10,
+     |         height: 10,
+     |         fill: "#fc0"
+     |     }
+     | ]);
+    \*/
+    paperproto.add = function (json) {
+        if (R.is(json, "array")) {
+            var res = this.set(),
+                i = 0,
+                ii = json.length,
+                j;
+            for (; i < ii; i++) {
+                j = json[i] || {};
+                elements[has](j.type) && res.push(this[j.type]().attr(j));
+            }
+        }
+        return res;
+    };
+
+    /*\
+     * Raphael.format
+     [ method ]
+     **
+     * Simple format function. Replaces construction of type “`{<number>}`” to the corresponding argument.
+     **
+     > Parameters
+     **
+     - token (string) string to format
+     - … (string) rest of arguments will be treated as parameters for replacement
+     = (string) formated string
+     > Usage
+     | var x = 10,
+     |     y = 20,
+     |     width = 40,
+     |     height = 50;
+     | // this will draw a rectangular shape equivalent to "M10,20h40v50h-40z"
+     | paper.path(Raphael.format("M{0},{1}h{2}v{3}h{4}z", x, y, width, height, -width));
+    \*/
+    R.format = function (token, params) {
+        var args = R.is(params, array) ? [0][concat](params) : arguments;
+        token && R.is(token, string) && args.length - 1 && (token = token.replace(formatrg, function (str, i) {
+            return args[++i] == null ? E : args[i];
+        }));
+        return token || E;
+    };
+    /*\
+     * Raphael.fullfill
+     [ method ]
+     **
+     * A little bit more advanced format function than @Raphael.format. Replaces construction of type “`{<name>}`” to the corresponding argument.
+     **
+     > Parameters
+     **
+     - token (string) string to format
+     - json (object) object which properties will be used as a replacement
+     = (string) formated string
+     > Usage
+     | // this will draw a rectangular shape equivalent to "M10,20h40v50h-40z"
+     | paper.path(Raphael.fullfill("M{x},{y}h{dim.width}v{dim.height}h{dim['negative width']}z", {
+     |     x: 10,
+     |     y: 20,
+     |     dim: {
+     |         width: 40,
+     |         height: 50,
+     |         "negative width": -40
+     |     }
+     | }));
+    \*/
+    R.fullfill = (function () {
+        var tokenRegex = /\{([^\}]+)\}/g,
+            objNotationRegex = /(?:(?:^|\.)(.+?)(?=\[|\.|$|\()|\[('|")(.+?)\2\])(\(\))?/g, // matches .xxxxx or ["xxxxx"] to run over object properties
+            replacer = function (all, key, obj) {
+                var res = obj;
+                key.replace(objNotationRegex, function (all, name, quote, quotedName, isFunc) {
+                    name = name || quotedName;
+                    if (res) {
+                        if (name in res) {
+                            res = res[name];
+                        }
+                        typeof res == "function" && isFunc && (res = res());
+                    }
+                });
+                res = (res == null || res == obj ? all : res) + "";
+                return res;
+            };
+        return function (str, obj) {
+            return String(str).replace(tokenRegex, function (all, key) {
+                return replacer(all, key, obj);
+            });
+        };
+    })();
+    /*\
+     * Raphael.ninja
+     [ method ]
+     **
+     * If you want to leave no trace of Raphaël (Well, Raphaël creates only one global variable `Raphael`, but anyway.) You can use `ninja` method.
+     * Beware, that in this case plugins could stop working, because they are depending on global variable existance.
+     **
+     = (object) Raphael object
+     > Usage
+     | (function (local_raphael) {
+     |     var paper = local_raphael(10, 10, 320, 200);
+     |     …
+     | })(Raphael.ninja());
+    \*/
+    R.ninja = function () {
+        oldRaphael.was ? (g.win.Raphael = oldRaphael.is) : delete Raphael;
+        return R;
+    };
+    /*\
+     * Raphael.st
+     [ property (object) ]
+     **
+     * You can add your own method to elements and sets. It is wise to add a set method for each element method
+     * you added, so you will be able to call the same method on sets too.
+     **
+     * See also @Raphael.el.
+     > Usage
+     | Raphael.el.red = function () {
+     |     this.attr({fill: "#f00"});
+     | };
+     | Raphael.st.red = function () {
+     |     this.forEach(function (el) {
+     |         el.red();
+     |     });
+     | };
+     | // then use it
+     | paper.set(paper.circle(100, 100, 20), paper.circle(110, 100, 20)).red();
+    \*/
+    R.st = setproto;
+    // Firefox <3.6 fix: http://webreflection.blogspot.com/2009/11/195-chars-to-help-lazy-loading.html
+    (function (doc, loaded, f) {
+        if (doc.readyState == null && doc.addEventListener){
+            doc.addEventListener(loaded, f = function () {
+                doc.removeEventListener(loaded, f, false);
+                doc.readyState = "complete";
+            }, false);
+            doc.readyState = "loading";
+        }
+        function isLoaded() {
+            (/in/).test(doc.readyState) ? setTimeout(isLoaded, 9) : R.eve("raphael.DOMload");
+        }
+        isLoaded();
+    })(document, "DOMContentLoaded");
+
+    eve.on("raphael.DOMload", function () {
+        loaded = true;
+    });
+
+// ┌─────────────────────────────────────────────────────────────────────┐ \\
+// │ Raphaël - JavaScript Vector Library                                 │ \\
+// ├─────────────────────────────────────────────────────────────────────┤ \\
+// │ SVG Module                                                          │ \\
+// ├─────────────────────────────────────────────────────────────────────┤ \\
+// │ Copyright (c) 2008-2011 Dmitry Baranovskiy (http://raphaeljs.com)   │ \\
+// │ Copyright (c) 2008-2011 Sencha Labs (http://sencha.com)             │ \\
+// │ Licensed under the MIT (http://raphaeljs.com/license.html) license. │ \\
+// └─────────────────────────────────────────────────────────────────────┘ \\
+
+(function(){
+    if (!R.svg) {
+        return;
+    }
+    var has = "hasOwnProperty",
+        Str = String,
+        toFloat = parseFloat,
+        toInt = parseInt,
+        math = Math,
+        mmax = math.max,
+        abs = math.abs,
+        pow = math.pow,
+        separator = /[, ]+/,
+        eve = R.eve,
+        E = "",
+        S = " ";
+    var xlink = "http://www.w3.org/1999/xlink",
+        markers = {
+            block: "M5,0 0,2.5 5,5z",
+            classic: "M5,0 0,2.5 5,5 3.5,3 3.5,2z",
+            diamond: "M2.5,0 5,2.5 2.5,5 0,2.5z",
+            open: "M6,1 1,3.5 6,6",
+            oval: "M2.5,0A2.5,2.5,0,0,1,2.5,5 2.5,2.5,0,0,1,2.5,0z"
+        },
+        markerCounter = {};
+    R.toString = function () {
+        return  "Your browser supports SVG.\nYou are running Rapha\xebl " + this.version;
+    };
+    var $ = function (el, attr) {
+        if (attr) {
+            if (typeof el == "string") {
+                el = $(el);
+            }
+            for (var key in attr) if (attr[has](key)) {
+                if (key.substring(0, 6) == "xlink:") {
+                    el.setAttributeNS(xlink, key.substring(6), Str(attr[key]));
+                } else {
+                    el.setAttribute(key, Str(attr[key]));
+                }
+            }
+        } else {
+            el = R._g.doc.createElementNS("http://www.w3.org/2000/svg", el);
+            el.style && (el.style.webkitTapHighlightColor = "rgba(0,0,0,0)");
+        }
+        return el;
+    },
+    addGradientFill = function (element, gradient) {
+        var type = "linear",
+            id = element.id + gradient,
+            fx = .5, fy = .5,
+            o = element.node,
+            SVG = element.paper,
+            s = o.style,
+            el = R._g.doc.getElementById(id);
+        if (!el) {
+            gradient = Str(gradient).replace(R._radial_gradient, function (all, _fx, _fy) {
+                type = "radial";
+                if (_fx && _fy) {
+                    fx = toFloat(_fx);
+                    fy = toFloat(_fy);
+                    var dir = ((fy > .5) * 2 - 1);
+                    pow(fx - .5, 2) + pow(fy - .5, 2) > .25 &&
+                        (fy = math.sqrt(.25 - pow(fx - .5, 2)) * dir + .5) &&
+                        fy != .5 &&
+                        (fy = fy.toFixed(5) - 1e-5 * dir);
+                }
+                return E;
+            });
+            gradient = gradient.split(/\s*\-\s*/);
+            if (type == "linear") {
+                var angle = gradient.shift();
+                angle = -toFloat(angle);
+                if (isNaN(angle)) {
+                    return null;
+                }
+                var vector = [0, 0, math.cos(R.rad(angle)), math.sin(R.rad(angle))],
+                    max = 1 / (mmax(abs(vector[2]), abs(vector[3])) || 1);
+                vector[2] *= max;
+                vector[3] *= max;
+                if (vector[2] < 0) {
+                    vector[0] = -vector[2];
+                    vector[2] = 0;
+                }
+                if (vector[3] < 0) {
+                    vector[1] = -vector[3];
+                    vector[3] = 0;
+                }
+            }
+            var dots = R._parseDots(gradient);
+            if (!dots) {
+                return null;
+            }
+            id = id.replace(/[\(\)\s,\xb0#]/g, "_");
+            
+            if (element.gradient && id != element.gradient.id) {
+                SVG.defs.removeChild(element.gradient);
+                delete element.gradient;
+            }
+
+            if (!element.gradient) {
+                el = $(type + "Gradient", {id: id});
+                element.gradient = el;
+                $(el, type == "radial" ? {
+                    fx: fx,
+                    fy: fy
+                } : {
+                    x1: vector[0],
+                    y1: vector[1],
+                    x2: vector[2],
+                    y2: vector[3],
+                    gradientTransform: element.matrix.invert()
+                });
+                SVG.defs.appendChild(el);
+                for (var i = 0, ii = dots.length; i < ii; i++) {
+                    el.appendChild($("stop", {
+                        offset: dots[i].offset ? dots[i].offset : i ? "100%" : "0%",
+                        "stop-color": dots[i].color || "#fff"
+                    }));
+                }
+            }
+        }
+        $(o, {
+            fill: "url(#" + id + ")",
+            opacity: 1,
+            "fill-opacity": 1
+        });
+        s.fill = E;
+        s.opacity = 1;
+        s.fillOpacity = 1;
+        return 1;
+    },
+    updatePosition = function (o) {
+        var bbox = o.getBBox(1);
+        $(o.pattern, {patternTransform: o.matrix.invert() + " translate(" + bbox.x + "," + bbox.y + ")"});
+    },
+    addArrow = function (o, value, isEnd) {
+        if (o.type == "path") {
+            var values = Str(value).toLowerCase().split("-"),
+                p = o.paper,
+                se = isEnd ? "end" : "start",
+                node = o.node,
+                attrs = o.attrs,
+                stroke = attrs["stroke-width"],
+                i = values.length,
+                type = "classic",
+                from,
+                to,
+                dx,
+                refX,
+                attr,
+                w = 3,
+                h = 3,
+                t = 5;
+            while (i--) {
+                switch (values[i]) {
+                    case "block":
+                    case "classic":
+                    case "oval":
+                    case "diamond":
+                    case "open":
+                    case "none":
+                        type = values[i];
+                        break;
+                    case "wide": h = 5; break;
+                    case "narrow": h = 2; break;
+                    case "long": w = 5; break;
+                    case "short": w = 2; break;
+                }
+            }
+            if (type == "open") {
+                w += 2;
+                h += 2;
+                t += 2;
+                dx = 1;
+                refX = isEnd ? 4 : 1;
+                attr = {
+                    fill: "none",
+                    stroke: attrs.stroke
+                };
+            } else {
+                refX = dx = w / 2;
+                attr = {
+                    fill: attrs.stroke,
+                    stroke: "none"
+                };
+            }
+            if (o._.arrows) {
+                if (isEnd) {
+                    o._.arrows.endPath && markerCounter[o._.arrows.endPath]--;
+                    o._.arrows.endMarker && markerCounter[o._.arrows.endMarker]--;
+                } else {
+                    o._.arrows.startPath && markerCounter[o._.arrows.startPath]--;
+                    o._.arrows.startMarker && markerCounter[o._.arrows.startMarker]--;
+                }
+            } else {
+                o._.arrows = {};
+            }
+            if (type != "none") {
+                var pathId = "raphael-marker-" + type,
+                    markerId = "raphael-marker-" + se + type + w + h;
+                if (!R._g.doc.getElementById(pathId)) {
+                    p.defs.appendChild($($("path"), {
+                        "stroke-linecap": "round",
+                        d: markers[type],
+                        id: pathId
+                    }));
+                    markerCounter[pathId] = 1;
+                } else {
+                    markerCounter[pathId]++;
+                }
+                var marker = R._g.doc.getElementById(markerId),
+                    use;
+                if (!marker) {
+                    marker = $($("marker"), {
+                        id: markerId,
+                        markerHeight: h,
+                        markerWidth: w,
+                        orient: "auto",
+                        refX: refX,
+                        refY: h / 2
+                    });
+                    use = $($("use"), {
+                        "xlink:href": "#" + pathId,
+                        transform: (isEnd ? "rotate(180 " + w / 2 + " " + h / 2 + ") " : E) + "scale(" + w / t + "," + h / t + ")",
+                        "stroke-width": (1 / ((w / t + h / t) / 2)).toFixed(4)
+                    });
+                    marker.appendChild(use);
+                    p.defs.appendChild(marker);
+                    markerCounter[markerId] = 1;
+                } else {
+                    markerCounter[markerId]++;
+                    use = marker.getElementsByTagName("use")[0];
+                }
+                $(use, attr);
+                var delta = dx * (type != "diamond" && type != "oval");
+                if (isEnd) {
+                    from = o._.arrows.startdx * stroke || 0;
+                    to = R.getTotalLength(attrs.path) - delta * stroke;
+                } else {
+                    from = delta * stroke;
+                    to = R.getTotalLength(attrs.path) - (o._.arrows.enddx * stroke || 0);
+                }
+                attr = {};
+                attr["marker-" + se] = "url(#" + markerId + ")";
+                if (to || from) {
+                    attr.d = R.getSubpath(attrs.path, from, to);
+                }
+                $(node, attr);
+                o._.arrows[se + "Path"] = pathId;
+                o._.arrows[se + "Marker"] = markerId;
+                o._.arrows[se + "dx"] = delta;
+                o._.arrows[se + "Type"] = type;
+                o._.arrows[se + "String"] = value;
+            } else {
+                if (isEnd) {
+                    from = o._.arrows.startdx * stroke || 0;
+                    to = R.getTotalLength(attrs.path) - from;
+                } else {
+                    from = 0;
+                    to = R.getTotalLength(attrs.path) - (o._.arrows.enddx * stroke || 0);
+                }
+                o._.arrows[se + "Path"] && $(node, {d: R.getSubpath(attrs.path, from, to)});
+                delete o._.arrows[se + "Path"];
+                delete o._.arrows[se + "Marker"];
+                delete o._.arrows[se + "dx"];
+                delete o._.arrows[se + "Type"];
+                delete o._.arrows[se + "String"];
+            }
+            for (attr in markerCounter) if (markerCounter[has](attr) && !markerCounter[attr]) {
+                var item = R._g.doc.getElementById(attr);
+                item && item.parentNode.removeChild(item);
+            }
+        }
+    },
+    dasharray = {
+        "": [0],
+        "none": [0],
+        "-": [3, 1],
+        ".": [1, 1],
+        "-.": [3, 1, 1, 1],
+        "-..": [3, 1, 1, 1, 1, 1],
+        ". ": [1, 3],
+        "- ": [4, 3],
+        "--": [8, 3],
+        "- .": [4, 3, 1, 3],
+        "--.": [8, 3, 1, 3],
+        "--..": [8, 3, 1, 3, 1, 3]
+    },
+    addDashes = function (o, value, params) {
+        value = dasharray[Str(value).toLowerCase()];
+        if (value) {
+            var width = o.attrs["stroke-width"] || "1",
+                butt = {round: width, square: width, butt: 0}[o.attrs["stroke-linecap"] || params["stroke-linecap"]] || 0,
+                dashes = [],
+                i = value.length;
+            while (i--) {
+                dashes[i] = value[i] * width + ((i % 2) ? 1 : -1) * butt;
+            }
+            $(o.node, {"stroke-dasharray": dashes.join(",")});
+        }
+    },
+    setFillAndStroke = function (o, params) {
+        var node = o.node,
+            attrs = o.attrs,
+            vis = node.style.visibility;
+        node.style.visibility = "hidden";
+        for (var att in params) {
+            if (params[has](att)) {
+                if (!R._availableAttrs[has](att)) {
+                    continue;
+                }
+                var value = params[att];
+                attrs[att] = value;
+                switch (att) {
+                    case "blur":
+                        o.blur(value);
+                        break;
+                    case "title":
+                        var title = node.getElementsByTagName("title");
+
+                        // Use the existing <title>.
+                        if (title.length && (title = title[0])) {
+                          title.firstChild.nodeValue = value;
+                        } else {
+                          title = $("title");
+                          var val = R._g.doc.createTextNode(value);
+                          title.appendChild(val);
+                          node.appendChild(title);
+                        }
+                        break;
+                    case "href":
+                    case "target":
+                        var pn = node.parentNode;
+                        if (pn.tagName.toLowerCase() != "a") {
+                            var hl = $("a");
+                            pn.insertBefore(hl, node);
+                            hl.appendChild(node);
+                            pn = hl;
+                        }
+                        if (att == "target") {
+                            pn.setAttributeNS(xlink, "show", value == "blank" ? "new" : value);
+                        } else {
+                            pn.setAttributeNS(xlink, att, value);
+                        }
+                        break;
+                    case "cursor":
+                        node.style.cursor = value;
+                        break;
+                    case "transform":
+                        o.transform(value);
+                        break;
+                    case "arrow-start":
+                        addArrow(o, value);
+                        break;
+                    case "arrow-end":
+                        addArrow(o, value, 1);
+                        break;
+                    case "clip-rect":
+                        var rect = Str(value).split(separator);
+                        if (rect.length == 4) {
+                            o.clip && o.clip.parentNode.parentNode.removeChild(o.clip.parentNode);
+                            var el = $("clipPath"),
+                                rc = $("rect");
+                            el.id = R.createUUID();
+                            $(rc, {
+                                x: rect[0],
+                                y: rect[1],
+                                width: rect[2],
+                                height: rect[3]
+                            });
+                            el.appendChild(rc);
+                            o.paper.defs.appendChild(el);
+                            $(node, {"clip-path": "url(#" + el.id + ")"});
+                            o.clip = rc;
+                        }
+                        if (!value) {
+                            var path = node.getAttribute("clip-path");
+                            if (path) {
+                                var clip = R._g.doc.getElementById(path.replace(/(^url\(#|\)$)/g, E));
+                                clip && clip.parentNode.removeChild(clip);
+                                $(node, {"clip-path": E});
+                                delete o.clip;
+                            }
+                        }
+                    break;
+                    case "path":
+                        if (o.type == "path") {
+                            $(node, {d: value ? attrs.path = R._pathToAbsolute(value) : "M0,0"});
+                            o._.dirty = 1;
+                            if (o._.arrows) {
+                                "startString" in o._.arrows && addArrow(o, o._.arrows.startString);
+                                "endString" in o._.arrows && addArrow(o, o._.arrows.endString, 1);
+                            }
+                        }
+                        break;
+                    case "width":
+                        node.setAttribute(att, value);
+                        o._.dirty = 1;
+                        if (attrs.fx) {
+                            att = "x";
+                            value = attrs.x;
+                        } else {
+                            break;
+                        }
+                    case "x":
+                        if (attrs.fx) {
+                            value = -attrs.x - (attrs.width || 0);
+                        }
+                    case "rx":
+                        if (att == "rx" && o.type == "rect") {
+                            break;
+                        }
+                    case "cx":
+                        node.setAttribute(att, value);
+                        o.pattern && updatePosition(o);
+                        o._.dirty = 1;
+                        break;
+                    case "height":
+                        node.setAttribute(att, value);
+                        o._.dirty = 1;
+                        if (attrs.fy) {
+                            att = "y";
+                            value = attrs.y;
+                        } else {
+                            break;
+                        }
+                    case "y":
+                        if (attrs.fy) {
+                            value = -attrs.y - (attrs.height || 0);
+                        }
+                    case "ry":
+                        if (att == "ry" && o.type == "rect") {
+                            break;
+                        }
+                    case "cy":
+                        node.setAttribute(att, value);
+                        o.pattern && updatePosition(o);
+                        o._.dirty = 1;
+                        break;
+                    case "r":
+                        if (o.type == "rect") {
+                            $(node, {rx: value, ry: value});
+                        } else {
+                            node.setAttribute(att, value);
+                        }
+                        o._.dirty = 1;
+                        break;
+                    case "src":
+                        if (o.type == "image") {
+                            node.setAttributeNS(xlink, "href", value);
+                        }
+                        break;
+                    case "stroke-width":
+                        if (o._.sx != 1 || o._.sy != 1) {
+                            value /= mmax(abs(o._.sx), abs(o._.sy)) || 1;
+                        }
+                        if (o.paper._vbSize) {
+                            value *= o.paper._vbSize;
+                        }
+                        node.setAttribute(att, value);
+                        if (attrs["stroke-dasharray"]) {
+                            addDashes(o, attrs["stroke-dasharray"], params);
+                        }
+                        if (o._.arrows) {
+                            "startString" in o._.arrows && addArrow(o, o._.arrows.startString);
+                            "endString" in o._.arrows && addArrow(o, o._.arrows.endString, 1);
+                        }
+                        break;
+                    case "stroke-dasharray":
+                        addDashes(o, value, params);
+                        break;
+                    case "fill":
+                        var isURL = Str(value).match(R._ISURL);
+                        if (isURL) {
+                            el = $("pattern");
+                            var ig = $("image");
+                            el.id = R.createUUID();
+                            $(el, {x: 0, y: 0, patternUnits: "userSpaceOnUse", height: 1, width: 1});
+                            $(ig, {x: 0, y: 0, "xlink:href": isURL[1]});
+                            el.appendChild(ig);
+
+                            (function (el) {
+                                R._preload(isURL[1], function () {
+                                    var w = this.offsetWidth,
+                                        h = this.offsetHeight;
+                                    $(el, {width: w, height: h});
+                                    $(ig, {width: w, height: h});
+                                    o.paper.safari();
+                                });
+                            })(el);
+                            o.paper.defs.appendChild(el);
+                            $(node, {fill: "url(#" + el.id + ")"});
+                            o.pattern = el;
+                            o.pattern && updatePosition(o);
+                            break;
+                        }
+                        var clr = R.getRGB(value);
+                        if (!clr.error) {
+                            delete params.gradient;
+                            delete attrs.gradient;
+                            !R.is(attrs.opacity, "undefined") &&
+                                R.is(params.opacity, "undefined") &&
+                                $(node, {opacity: attrs.opacity});
+                            !R.is(attrs["fill-opacity"], "undefined") &&
+                                R.is(params["fill-opacity"], "undefined") &&
+                                $(node, {"fill-opacity": attrs["fill-opacity"]});
+                        } else if ((o.type == "circle" || o.type == "ellipse" || Str(value).charAt() != "r") && addGradientFill(o, value)) {
+                            if ("opacity" in attrs || "fill-opacity" in attrs) {
+                                var gradient = R._g.doc.getElementById(node.getAttribute("fill").replace(/^url\(#|\)$/g, E));
+                                if (gradient) {
+                                    var stops = gradient.getElementsByTagName("stop");
+                                    $(stops[stops.length - 1], {"stop-opacity": ("opacity" in attrs ? attrs.opacity : 1) * ("fill-opacity" in attrs ? attrs["fill-opacity"] : 1)});
+                                }
+                            }
+                            attrs.gradient = value;
+                            attrs.fill = "none";
+                            break;
+                        }
+                        clr[has]("opacity") && $(node, {"fill-opacity": clr.opacity > 1 ? clr.opacity / 100 : clr.opacity});
+                    case "stroke":
+                        clr = R.getRGB(value);
+                        node.setAttribute(att, clr.hex);
+                        att == "stroke" && clr[has]("opacity") && $(node, {"stroke-opacity": clr.opacity > 1 ? clr.opacity / 100 : clr.opacity});
+                        if (att == "stroke" && o._.arrows) {
+                            "startString" in o._.arrows && addArrow(o, o._.arrows.startString);
+                            "endString" in o._.arrows && addArrow(o, o._.arrows.endString, 1);
+                        }
+                        break;
+                    case "gradient":
+                        (o.type == "circle" || o.type == "ellipse" || Str(value).charAt() != "r") && addGradientFill(o, value);
+                        break;
+                    case "opacity":
+                        if (attrs.gradient && !attrs[has]("stroke-opacity")) {
+                            $(node, {"stroke-opacity": value > 1 ? value / 100 : value});
+                        }
+                        // fall
+                    case "fill-opacity":
+                        if (attrs.gradient) {
+                            gradient = R._g.doc.getElementById(node.getAttribute("fill").replace(/^url\(#|\)$/g, E));
+                            if (gradient) {
+                                stops = gradient.getElementsByTagName("stop");
+                                $(stops[stops.length - 1], {"stop-opacity": value});
+                            }
+                            break;
+                        }
+                    default:
+                        att == "font-size" && (value = toInt(value, 10) + "px");
+                        var cssrule = att.replace(/(\-.)/g, function (w) {
+                            return w.substring(1).toUpperCase();
+                        });
+                        node.style[cssrule] = value;
+                        o._.dirty = 1;
+                        node.setAttribute(att, value);
+                        break;
+                }
+            }
+        }
+
+        tuneText(o, params);
+        node.style.visibility = vis;
+    },
+    leading = 1.2,
+    tuneText = function (el, params) {
+        if (el.type != "text" || !(params[has]("text") || params[has]("font") || params[has]("font-size") || params[has]("x") || params[has]("y"))) {
+            return;
+        }
+        var a = el.attrs,
+            node = el.node,
+            fontSize = node.firstChild ? toInt(R._g.doc.defaultView.getComputedStyle(node.firstChild, E).getPropertyValue("font-size"), 10) : 10;
+
+        if (params[has]("text")) {
+            a.text = params.text;
+            while (node.firstChild) {
+                node.removeChild(node.firstChild);
+            }
+            var texts = Str(params.text).split("\n"),
+                tspans = [],
+                tspan;
+            for (var i = 0, ii = texts.length; i < ii; i++) {
+                tspan = $("tspan");
+                i && $(tspan, {dy: fontSize * leading, x: a.x});
+                tspan.appendChild(R._g.doc.createTextNode(texts[i]));
+                node.appendChild(tspan);
+                tspans[i] = tspan;
+            }
+        } else {
+            tspans = node.getElementsByTagName("tspan");
+            for (i = 0, ii = tspans.length; i < ii; i++) if (i) {
+                $(tspans[i], {dy: fontSize * leading, x: a.x});
+            } else {
+                $(tspans[0], {dy: 0});
+            }
+        }
+        $(node, {x: a.x, y: a.y});
+        el._.dirty = 1;
+        var bb = el._getBBox(),
+            dif = a.y - (bb.y + bb.height / 2);
+        dif && R.is(dif, "finite") && $(tspans[0], {dy: dif});
+    },
+    Element = function (node, svg) {
+        var X = 0,
+            Y = 0;
+        /*\
+         * Element.node
+         [ property (object) ]
+         **
+         * Gives you a reference to the DOM object, so you can assign event handlers or just mess around.
+         **
+         * Note: Don’t mess with it.
+         > Usage
+         | // draw a circle at coordinate 10,10 with radius of 10
+         | var c = paper.circle(10, 10, 10);
+         | c.node.onclick = function () {
+         |     c.attr("fill", "red");
+         | };
+        \*/
+        this[0] = this.node = node;
+        /*\
+         * Element.raphael
+         [ property (object) ]
+         **
+         * Internal reference to @Raphael object. In case it is not available.
+         > Usage
+         | Raphael.el.red = function () {
+         |     var hsb = this.paper.raphael.rgb2hsb(this.attr("fill"));
+         |     hsb.h = 1;
+         |     this.attr({fill: this.paper.raphael.hsb2rgb(hsb).hex});
+         | }
+        \*/
+        node.raphael = true;
+        /*\
+         * Element.id
+         [ property (number) ]
+         **
+         * Unique id of the element. Especially usesful when you want to listen to events of the element, 
+         * because all events are fired in format `<module>.<action>.<id>`. Also useful for @Paper.getById method.
+        \*/
+        this.id = R._oid++;
+        node.raphaelid = this.id;
+        this.matrix = R.matrix();
+        this.realPath = null;
+        /*\
+         * Element.paper
+         [ property (object) ]
+         **
+         * Internal reference to “paper” where object drawn. Mainly for use in plugins and element extensions.
+         > Usage
+         | Raphael.el.cross = function () {
+         |     this.attr({fill: "red"});
+         |     this.paper.path("M10,10L50,50M50,10L10,50")
+         |         .attr({stroke: "red"});
+         | }
+        \*/
+        this.paper = svg;
+        this.attrs = this.attrs || {};
+        this._ = {
+            transform: [],
+            sx: 1,
+            sy: 1,
+            deg: 0,
+            dx: 0,
+            dy: 0,
+            dirty: 1
+        };
+        !svg.bottom && (svg.bottom = this);
+        /*\
+         * Element.prev
+         [ property (object) ]
+         **
+         * Reference to the previous element in the hierarchy.
+        \*/
+        this.prev = svg.top;
+        svg.top && (svg.top.next = this);
+        svg.top = this;
+        /*\
+         * Element.next
+         [ property (object) ]
+         **
+         * Reference to the next element in the hierarchy.
+        \*/
+        this.next = null;
+    },
+    elproto = R.el;
+
+    Element.prototype = elproto;
+    elproto.constructor = Element;
+
+    R._engine.path = function (pathString, SVG) {
+        var el = $("path");
+        SVG.canvas && SVG.canvas.appendChild(el);
+        var p = new Element(el, SVG);
+        p.type = "path";
+        setFillAndStroke(p, {
+            fill: "none",
+            stroke: "#000",
+            path: pathString
+        });
+        return p;
+    };
+    /*\
+     * Element.rotate
+     [ method ]
+     **
+     * Deprecated! Use @Element.transform instead.
+     * Adds rotation by given angle around given point to the list of
+     * transformations of the element.
+     > Parameters
+     - deg (number) angle in degrees
+     - cx (number) #optional x coordinate of the centre of rotation
+     - cy (number) #optional y coordinate of the centre of rotation
+     * If cx & cy aren’t specified centre of the shape is used as a point of rotation.
+     = (object) @Element
+    \*/
+    elproto.rotate = function (deg, cx, cy) {
+        if (this.removed) {
+            return this;
+        }
+        deg = Str(deg).split(separator);
+        if (deg.length - 1) {
+            cx = toFloat(deg[1]);
+            cy = toFloat(deg[2]);
+        }
+        deg = toFloat(deg[0]);
+        (cy == null) && (cx = cy);
+        if (cx == null || cy == null) {
+            var bbox = this.getBBox(1);
+            cx = bbox.x + bbox.width / 2;
+            cy = bbox.y + bbox.height / 2;
+        }
+        this.transform(this._.transform.concat([["r", deg, cx, cy]]));
+        return this;
+    };
+    /*\
+     * Element.scale
+     [ method ]
+     **
+     * Deprecated! Use @Element.transform instead.
+     * Adds scale by given amount relative to given point to the list of
+     * transformations of the element.
+     > Parameters
+     - sx (number) horisontal scale amount
+     - sy (number) vertical scale amount
+     - cx (number) #optional x coordinate of the centre of scale
+     - cy (number) #optional y coordinate of the centre of scale
+     * If cx & cy aren’t specified centre of the shape is used instead.
+     = (object) @Element
+    \*/
+    elproto.scale = function (sx, sy, cx, cy) {
+        if (this.removed) {
+            return this;
+        }
+        sx = Str(sx).split(separator);
+        if (sx.length - 1) {
+            sy = toFloat(sx[1]);
+            cx = toFloat(sx[2]);
+            cy = toFloat(sx[3]);
+        }
+        sx = toFloat(sx[0]);
+        (sy == null) && (sy = sx);
+        (cy == null) && (cx = cy);
+        if (cx == null || cy == null) {
+            var bbox = this.getBBox(1);
+        }
+        cx = cx == null ? bbox.x + bbox.width / 2 : cx;
+        cy = cy == null ? bbox.y + bbox.height / 2 : cy;
+        this.transform(this._.transform.concat([["s", sx, sy, cx, cy]]));
+        return this;
+    };
+    /*\
+     * Element.translate
+     [ method ]
+     **
+     * Deprecated! Use @Element.transform instead.
+     * Adds translation by given amount to the list of transformations of the element.
+     > Parameters
+     - dx (number) horisontal shift
+     - dy (number) vertical shift
+     = (object) @Element
+    \*/
+    elproto.translate = function (dx, dy) {
+        if (this.removed) {
+            return this;
+        }
+        dx = Str(dx).split(separator);
+        if (dx.length - 1) {
+            dy = toFloat(dx[1]);
+        }
+        dx = toFloat(dx[0]) || 0;
+        dy = +dy || 0;
+        this.transform(this._.transform.concat([["t", dx, dy]]));
+        return this;
+    };
+    /*\
+     * Element.transform
+     [ method ]
+     **
+     * Adds transformation to the element which is separate to other attributes,
+     * i.e. translation doesn’t change `x` or `y` of the rectange. The format
+     * of transformation string is similar to the path string syntax:
+     | "t100,100r30,100,100s2,2,100,100r45s1.5"
+     * Each letter is a command. There are four commands: `t` is for translate, `r` is for rotate, `s` is for
+     * scale and `m` is for matrix.
+     *
+     * There are also alternative “absolute” translation, rotation and scale: `T`, `R` and `S`. They will not take previous transformation into account. For example, `...T100,0` will always move element 100 px horisontally, while `...t100,0` could move it vertically if there is `r90` before. Just compare results of `r90t100,0` and `r90T100,0`.
+     *
+     * So, the example line above could be read like “translate by 100, 100; rotate 30° around 100, 100; scale twice around 100, 100;
+     * rotate 45° around centre; scale 1.5 times relative to centre”. As you can see rotate and scale commands have origin
+     * coordinates as optional parameters, the default is the centre point of the element.
+     * Matrix accepts six parameters.
+     > Usage
+     | var el = paper.rect(10, 20, 300, 200);
+     | // translate 100, 100, rotate 45°, translate -100, 0
+     | el.transform("t100,100r45t-100,0");
+     | // if you want you can append or prepend transformations
+     | el.transform("...t50,50");
+     | el.transform("s2...");
+     | // or even wrap
+     | el.transform("t50,50...t-50-50");
+     | // to reset transformation call method with empty string
+     | el.transform("");
+     | // to get current value call it without parameters
+     | console.log(el.transform());
+     > Parameters
+     - tstr (string) #optional transformation string
+     * If tstr isn’t specified
+     = (string) current transformation string
+     * else
+     = (object) @Element
+    \*/
+    elproto.transform = function (tstr) {
+        var _ = this._;
+        if (tstr == null) {
+            return _.transform;
+        }
+        R._extractTransform(this, tstr);
+
+        this.clip && $(this.clip, {transform: this.matrix.invert()});
+        this.pattern && updatePosition(this);
+        this.node && $(this.node, {transform: this.matrix});
+    
+        if (_.sx != 1 || _.sy != 1) {
+            var sw = this.attrs[has]("stroke-width") ? this.attrs["stroke-width"] : 1;
+            this.attr({"stroke-width": sw});
+        }
+
+        return this;
+    };
+    /*\
+     * Element.hide
+     [ method ]
+     **
+     * Makes element invisible. See @Element.show.
+     = (object) @Element
+    \*/
+    elproto.hide = function () {
+        !this.removed && this.paper.safari(this.node.style.display = "none");
+        return this;
+    };
+    /*\
+     * Element.show
+     [ method ]
+     **
+     * Makes element visible. See @Element.hide.
+     = (object) @Element
+    \*/
+    elproto.show = function () {
+        !this.removed && this.paper.safari(this.node.style.display = "");
+        return this;
+    };
+    /*\
+     * Element.remove
+     [ method ]
+     **
+     * Removes element from the paper.
+    \*/
+    elproto.remove = function () {
+        if (this.removed || !this.node.parentNode) {
+            return;
+        }
+        var paper = this.paper;
+        paper.__set__ && paper.__set__.exclude(this);
+        eve.unbind("raphael.*.*." + this.id);
+        if (this.gradient) {
+            paper.defs.removeChild(this.gradient);
+        }
+        R._tear(this, paper);
+        if (this.node.parentNode.tagName.toLowerCase() == "a") {
+            this.node.parentNode.parentNode.removeChild(this.node.parentNode);
+        } else {
+            this.node.parentNode.removeChild(this.node);
+        }
+        for (var i in this) {
+            this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null;
+        }
+        this.removed = true;
+    };
+    elproto._getBBox = function () {
+        if (this.node.style.display == "none") {
+            this.show();
+            var hide = true;
+        }
+        var bbox = {};
+        try {
+            bbox = this.node.getBBox();
+        } catch(e) {
+            // Firefox 3.0.x plays badly here
+        } finally {
+            bbox = bbox || {};
+        }
+        hide && this.hide();
+        return bbox;
+    };
+    /*\
+     * Element.attr
+     [ method ]
+     **
+     * Sets the attributes of the element.
+     > Parameters
+     - attrName (string) attribute’s name
+     - value (string) value
+     * or
+     - params (object) object of name/value pairs
+     * or
+     - attrName (string) attribute’s name
+     * or
+     - attrNames (array) in this case method returns array of current values for given attribute names
+     = (object) @Element if attrsName & value or params are passed in.
+     = (...) value of the attribute if only attrsName is passed in.
+     = (array) array of values of the attribute if attrsNames is passed in.
+     = (object) object of attributes if nothing is passed in.
+     > Possible parameters
+     # <p>Please refer to the <a href="http://www.w3.org/TR/SVG/" title="The W3C Recommendation for the SVG language describes these properties in detail.">SVG specification</a> for an explanation of these parameters.</p>
+     o arrow-end (string) arrowhead on the end of the path. The format for string is `<type>[-<width>[-<length>]]`. Possible types: `classic`, `block`, `open`, `oval`, `diamond`, `none`, width: `wide`, `narrow`, `medium`, length: `long`, `short`, `midium`.
+     o clip-rect (string) comma or space separated values: x, y, width and height
+     o cursor (string) CSS type of the cursor
+     o cx (number) the x-axis coordinate of the center of the circle, or ellipse
+     o cy (number) the y-axis coordinate of the center of the circle, or ellipse
+     o fill (string) colour, gradient or image
+     o fill-opacity (number)
+     o font (string)
+     o font-family (string)
+     o font-size (number) font size in pixels
+     o font-weight (string)
+     o height (number)
+     o href (string) URL, if specified element behaves as hyperlink
+     o opacity (number)
+     o path (string) SVG path string format
+     o r (number) radius of the circle, ellipse or rounded corner on the rect
+     o rx (number) horisontal radius of the ellipse
+     o ry (number) vertical radius of the ellipse
+     o src (string) image URL, only works for @Element.image element
+     o stroke (string) stroke colour
+     o stroke-dasharray (string) [“”, “`-`”, “`.`”, “`-.`”, “`-..`”, “`. `”, “`- `”, “`--`”, “`- .`”, “`--.`”, “`--..`”]
+     o stroke-linecap (string) [“`butt`”, “`square`”, “`round`”]
+     o stroke-linejoin (string) [“`bevel`”, “`round`”, “`miter`”]
+     o stroke-miterlimit (number)
+     o stroke-opacity (number)
+     o stroke-width (number) stroke width in pixels, default is '1'
+     o target (string) used with href
+     o text (string) contents of the text element. Use `\n` for multiline text
+     o text-anchor (string) [“`start`”, “`middle`”, “`end`”], default is “`middle`”
+     o title (string) will create tooltip with a given text
+     o transform (string) see @Element.transform
+     o width (number)
+     o x (number)
+     o y (number)
+     > Gradients
+     * Linear gradient format: “`‹angle›-‹colour›[-‹colour›[:‹offset›]]*-‹colour›`”, example: “`90-#fff-#000`” – 90°
+     * gradient from white to black or “`0-#fff-#f00:20-#000`” – 0° gradient from white via red (at 20%) to black.
+     *
+     * radial gradient: “`r[(‹fx›, ‹fy›)]‹colour›[-‹colour›[:‹offset›]]*-‹colour›`”, example: “`r#fff-#000`” –
+     * gradient from white to black or “`r(0.25, 0.75)#fff-#000`” – gradient from white to black with focus point
+     * at 0.25, 0.75. Focus point coordinates are in 0..1 range. Radial gradients can only be applied to circles and ellipses.
+     > Path String
+     # <p>Please refer to <a href="http://www.w3.org/TR/SVG/paths.html#PathData" title="Details of a path’s data attribute’s format are described in the SVG specification.">SVG documentation regarding path string</a>. Raphaël fully supports it.</p>
+     > Colour Parsing
+     # <ul>
+     #     <li>Colour name (“<code>red</code>”, “<code>green</code>”, “<code>cornflowerblue</code>”, etc)</li>
+     #     <li>#••• — shortened HTML colour: (“<code>#000</code>”, “<code>#fc0</code>”, etc)</li>
+     #     <li>#•••••• — full length HTML colour: (“<code>#000000</code>”, “<code>#bd2300</code>”)</li>
+     #     <li>rgb(•••, •••, •••) — red, green and blue channels’ values: (“<code>rgb(200,&nbsp;100,&nbsp;0)</code>”)</li>
+     #     <li>rgb(•••%, •••%, •••%) — same as above, but in %: (“<code>rgb(100%,&nbsp;175%,&nbsp;0%)</code>”)</li>
+     #     <li>rgba(•••, •••, •••, •••) — red, green and blue channels’ values: (“<code>rgba(200,&nbsp;100,&nbsp;0, .5)</code>”)</li>
+     #     <li>rgba(•••%, •••%, •••%, •••%) — same as above, but in %: (“<code>rgba(100%,&nbsp;175%,&nbsp;0%, 50%)</code>”)</li>
+     #     <li>hsb(•••, •••, •••) — hue, saturation and brightness values: (“<code>hsb(0.5,&nbsp;0.25,&nbsp;1)</code>”)</li>
+     #     <li>hsb(•••%, •••%, •••%) — same as above, but in %</li>
+     #     <li>hsba(•••, •••, •••, •••) — same as above, but with opacity</li>
+     #     <li>hsl(•••, •••, •••) — almost the same as hsb, see <a href="http://en.wikipedia.org/wiki/HSL_and_HSV" title="HSL and HSV - Wikipedia, the free encyclopedia">Wikipedia page</a></li>
+     #     <li>hsl(•••%, •••%, •••%) — same as above, but in %</li>
+     #     <li>hsla(•••, •••, •••, •••) — same as above, but with opacity</li>
+     #     <li>Optionally for hsb and hsl you could specify hue as a degree: “<code>hsl(240deg,&nbsp;1,&nbsp;.5)</code>” or, if you want to go fancy, “<code>hsl(240°,&nbsp;1,&nbsp;.5)</code>”</li>
+     # </ul>
+    \*/
+    elproto.attr = function (name, value) {
+        if (this.removed) {
+            return this;
+        }
+        if (name == null) {
+            var res = {};
+            for (var a in this.attrs) if (this.attrs[has](a)) {
+                res[a] = this.attrs[a];
+            }
+            res.gradient && res.fill == "none" && (res.fill = res.gradient) && delete res.gradient;
+            res.transform = this._.transform;
+            return res;
+        }
+        if (value == null && R.is(name, "string")) {
+            if (name == "fill" && this.attrs.fill == "none" && this.attrs.gradient) {
+                return this.attrs.gradient;
+            }
+            if (name == "transform") {
+                return this._.transform;
+            }
+            var names = name.split(separator),
+                out = {};
+            for (var i = 0, ii = names.length; i < ii; i++) {
+                name = names[i];
+                if (name in this.attrs) {
+                    out[name] = this.attrs[name];
+                } else if (R.is(this.paper.customAttributes[name], "function")) {
+                    out[name] = this.paper.customAttributes[name].def;
+                } else {
+                    out[name] = R._availableAttrs[name];
+                }
+            }
+            return ii - 1 ? out : out[names[0]];
+        }
+        if (value == null && R.is(name, "array")) {
+            out = {};
+            for (i = 0, ii = name.length; i < ii; i++) {
+                out[name[i]] = this.attr(name[i]);
+            }
+            return out;
+        }
+        if (value != null) {
+            var params = {};
+            params[name] = value;
+        } else if (name != null && R.is(name, "object")) {
+            params = name;
+        }
+        for (var key in params) {
+            eve("raphael.attr." + key + "." + this.id, this, params[key]);
+        }
+        for (key in this.paper.customAttributes) if (this.paper.customAttributes[has](key) && params[has](key) && R.is(this.paper.customAttributes[key], "function")) {
+            var par = this.paper.customAttributes[key].apply(this, [].concat(params[key]));
+            this.attrs[key] = params[key];
+            for (var subkey in par) if (par[has](subkey)) {
+                params[subkey] = par[subkey];
+            }
+        }
+        setFillAndStroke(this, params);
+        return this;
+    };
+    /*\
+     * Element.toFront
+     [ method ]
+     **
+     * Moves the element so it is the closest to the viewer’s eyes, on top of other elements.
+     = (object) @Element
+    \*/
+    elproto.toFront = function () {
+        if (this.removed) {
+            return this;
+        }
+        if (this.node.parentNode.tagName.toLowerCase() == "a") {
+            this.node.parentNode.parentNode.appendChild(this.node.parentNode);
+        } else {
+            this.node.parentNode.appendChild(this.node);
+        }
+        var svg = this.paper;
+        svg.top != this && R._tofront(this, svg);
+        return this;
+    };
+    /*\
+     * Element.toBack
+     [ method ]
+     **
+     * Moves the element so it is the furthest from the viewer’s eyes, behind other elements.
+     = (object) @Element
+    \*/
+    elproto.toBack = function () {
+        if (this.removed) {
+            return this;
+        }
+        var parent = this.node.parentNode;
+        if (parent.tagName.toLowerCase() == "a") {
+            parent.parentNode.insertBefore(this.node.parentNode, this.node.parentNode.parentNode.firstChild); 
+        } else if (parent.firstChild != this.node) {
+            parent.insertBefore(this.node, this.node.parentNode.firstChild);
+        }
+        R._toback(this, this.paper);
+        var svg = this.paper;
+        return this;
+    };
+    /*\
+     * Element.insertAfter
+     [ method ]
+     **
+     * Inserts current object after the given one.
+     = (object) @Element
+    \*/
+    elproto.insertAfter = function (element) {
+        if (this.removed) {
+            return this;
+        }
+        var node = element.node || element[element.length - 1].node;
+        if (node.nextSibling) {
+            node.parentNode.insertBefore(this.node, node.nextSibling);
+        } else {
+            node.parentNode.appendChild(this.node);
+        }
+        R._insertafter(this, element, this.paper);
+        return this;
+    };
+    /*\
+     * Element.insertBefore
+     [ method ]
+     **
+     * Inserts current object before the given one.
+     = (object) @Element
+    \*/
+    elproto.insertBefore = function (element) {
+        if (this.removed) {
+            return this;
+        }
+        var node = element.node || element[0].node;
+        node.parentNode.insertBefore(this.node, node);
+        R._insertbefore(this, element, this.paper);
+        return this;
+    };
+    elproto.blur = function (size) {
+        // Experimental. No Safari support. Use it on your own risk.
+        var t = this;
+        if (+size !== 0) {
+            var fltr = $("filter"),
+                blur = $("feGaussianBlur");
+            t.attrs.blur = size;
+            fltr.id = R.createUUID();
+            $(blur, {stdDeviation: +size || 1.5});
+            fltr.appendChild(blur);
+            t.paper.defs.appendChild(fltr);
+            t._blur = fltr;
+            $(t.node, {filter: "url(#" + fltr.id + ")"});
+        } else {
+            if (t._blur) {
+                t._blur.parentNode.removeChild(t._blur);
+                delete t._blur;
+                delete t.attrs.blur;
+            }
+            t.node.removeAttribute("filter");
+        }
+        return t;
+    };
+    R._engine.circle = function (svg, x, y, r) {
+        var el = $("circle");
+        svg.canvas && svg.canvas.appendChild(el);
+        var res = new Element(el, svg);
+        res.attrs = {cx: x, cy: y, r: r, fill: "none", stroke: "#000"};
+        res.type = "circle";
+        $(el, res.attrs);
+        return res;
+    };
+    R._engine.rect = function (svg, x, y, w, h, r) {
+        var el = $("rect");
+        svg.canvas && svg.canvas.appendChild(el);
+        var res = new Element(el, svg);
+        res.attrs = {x: x, y: y, width: w, height: h, r: r || 0, rx: r || 0, ry: r || 0, fill: "none", stroke: "#000"};
+        res.type = "rect";
+        $(el, res.attrs);
+        return res;
+    };
+    R._engine.ellipse = function (svg, x, y, rx, ry) {
+        var el = $("ellipse");
+        svg.canvas && svg.canvas.appendChild(el);
+        var res = new Element(el, svg);
+        res.attrs = {cx: x, cy: y, rx: rx, ry: ry, fill: "none", stroke: "#000"};
+        res.type = "ellipse";
+        $(el, res.attrs);
+        return res;
+    };
+    R._engine.image = function (svg, src, x, y, w, h) {
+        var el = $("image");
+        $(el, {x: x, y: y, width: w, height: h, preserveAspectRatio: "none"});
+        el.setAttributeNS(xlink, "href", src);
+        svg.canvas && svg.canvas.appendChild(el);
+        var res = new Element(el, svg);
+        res.attrs = {x: x, y: y, width: w, height: h, src: src};
+        res.type = "image";
+        return res;
+    };
+    R._engine.text = function (svg, x, y, text) {
+        var el = $("text");
+        svg.canvas && svg.canvas.appendChild(el);
+        var res = new Element(el, svg);
+        res.attrs = {
+            x: x,
+            y: y,
+            "text-anchor": "middle",
+            text: text,
+            font: R._availableAttrs.font,
+            stroke: "none",
+            fill: "#000"
+        };
+        res.type = "text";
+        setFillAndStroke(res, res.attrs);
+        return res;
+    };
+    R._engine.setSize = function (width, height) {
+        this.width = width || this.width;
+        this.height = height || this.height;
+        this.canvas.setAttribute("width", this.width);
+        this.canvas.setAttribute("height", this.height);
+        if (this._viewBox) {
+            this.setViewBox.apply(this, this._viewBox);
+        }
+        return this;
+    };
+    R._engine.create = function () {
+        var con = R._getContainer.apply(0, arguments),
+            container = con && con.container,
+            x = con.x,
+            y = con.y,
+            width = con.width,
+            height = con.height;
+        if (!container) {
+            throw new Error("SVG container not found.");
+        }
+        var cnvs = $("svg"),
+            css = "overflow:hidden;",
+            isFloating;
+        x = x || 0;
+        y = y || 0;
+        width = width || 512;
+        height = height || 342;
+        $(cnvs, {
+            height: height,
+            version: 1.1,
+            width: width,
+            xmlns: "http://www.w3.org/2000/svg"
+        });
+        if (container == 1) {
+            cnvs.style.cssText = css + "position:absolute;left:" + x + "px;top:" + y + "px";
+            R._g.doc.body.appendChild(cnvs);
+            isFloating = 1;
+        } else {
+            cnvs.style.cssText = css + "position:relative";
+            if (container.firstChild) {
+                container.insertBefore(cnvs, container.firstChild);
+            } else {
+                container.appendChild(cnvs);
+            }
+        }
+        container = new R._Paper;
+        container.width = width;
+        container.height = height;
+        container.canvas = cnvs;
+        container.clear();
+        container._left = container._top = 0;
+        isFloating && (container.renderfix = function () {});
+        container.renderfix();
+        return container;
+    };
+    R._engine.setViewBox = function (x, y, w, h, fit) {
+        eve("raphael.setViewBox", this, this._viewBox, [x, y, w, h, fit]);
+        var size = mmax(w / this.width, h / this.height),
+            top = this.top,
+            aspectRatio = fit ? "xMidYMid meet" : "xMinYMin",
+            vb,
+            sw;
+        if (x == null) {
+            if (this._vbSize) {
+                size = 1;
+            }
+            delete this._vbSize;
+            vb = "0 0 " + this.width + S + this.height;
+        } else {
+            this._vbSize = size;
+            vb = x + S + y + S + w + S + h;
+        }
+        $(this.canvas, {
+            viewBox: vb,
+            preserveAspectRatio: aspectRatio
+        });
+        while (size && top) {
+            sw = "stroke-width" in top.attrs ? top.attrs["stroke-width"] : 1;
+            top.attr({"stroke-width": sw});
+            top._.dirty = 1;
+            top._.dirtyT = 1;
+            top = top.prev;
+        }
+        this._viewBox = [x, y, w, h, !!fit];
+        return this;
+    };
+    /*\
+     * Paper.renderfix
+     [ method ]
+     **
+     * Fixes the issue of Firefox and IE9 regarding subpixel rendering. If paper is dependant
+     * on other elements after reflow it could shift half pixel which cause for lines to lost their crispness.
+     * This method fixes the issue.
+     **
+       Special thanks to Mariusz Nowak (http://www.medikoo.com/) for this method.
+    \*/
+    R.prototype.renderfix = function () {
+        var cnvs = this.canvas,
+            s = cnvs.style,
+            pos;
+        try {
+            pos = cnvs.getScreenCTM() || cnvs.createSVGMatrix();
+        } catch (e) {
+            pos = cnvs.createSVGMatrix();
+        }
+        var left = -pos.e % 1,
+            top = -pos.f % 1;
+        if (left || top) {
+            if (left) {
+                this._left = (this._left + left) % 1;
+                s.left = this._left + "px";
+            }
+            if (top) {
+                this._top = (this._top + top) % 1;
+                s.top = this._top + "px";
+            }
+        }
+    };
+    /*\
+     * Paper.clear
+     [ method ]
+     **
+     * Clears the paper, i.e. removes all the elements.
+    \*/
+    R.prototype.clear = function () {
+        R.eve("raphael.clear", this);
+        var c = this.canvas;
+        while (c.firstChild) {
+            c.removeChild(c.firstChild);
+        }
+        this.bottom = this.top = null;
+        (this.desc = $("desc")).appendChild(R._g.doc.createTextNode("Created with Rapha\xebl " + R.version));
+        c.appendChild(this.desc);
+        c.appendChild(this.defs = $("defs"));
+    };
+    /*\
+     * Paper.remove
+     [ method ]
+     **
+     * Removes the paper from the DOM.
+    \*/
+    R.prototype.remove = function () {
+        eve("raphael.remove", this);
+        this.canvas.parentNode && this.canvas.parentNode.removeChild(this.canvas);
+        for (var i in this) {
+            this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null;
+        }
+    };
+    var setproto = R.st;
+    for (var method in elproto) if (elproto[has](method) && !setproto[has](method)) {
+        setproto[method] = (function (methodname) {
+            return function () {
+                var arg = arguments;
+                return this.forEach(function (el) {
+                    el[methodname].apply(el, arg);
+                });
+            };
+        })(method);
+    }
+})();
+
+// ┌─────────────────────────────────────────────────────────────────────┐ \\
+// │ Raphaël - JavaScript Vector Library                                 │ \\
+// ├─────────────────────────────────────────────────────────────────────┤ \\
+// │ VML Module                                                          │ \\
+// ├─────────────────────────────────────────────────────────────────────┤ \\
+// │ Copyright (c) 2008-2011 Dmitry Baranovskiy (http://raphaeljs.com)   │ \\
+// │ Copyright (c) 2008-2011 Sencha Labs (http://sencha.com)             │ \\
+// │ Licensed under the MIT (http://raphaeljs.com/license.html) license. │ \\
+// └─────────────────────────────────────────────────────────────────────┘ \\
+
+(function(){
+    if (!R.vml) {
+        return;
+    }
+    var has = "hasOwnProperty",
+        Str = String,
+        toFloat = parseFloat,
+        math = Math,
+        round = math.round,
+        mmax = math.max,
+        mmin = math.min,
+        abs = math.abs,
+        fillString = "fill",
+        separator = /[, ]+/,
+        eve = R.eve,
+        ms = " progid:DXImageTransform.Microsoft",
+        S = " ",
+        E = "",
+        map = {M: "m", L: "l", C: "c", Z: "x", m: "t", l: "r", c: "v", z: "x"},
+        bites = /([clmz]),?([^clmz]*)/gi,
+        blurregexp = / progid:\S+Blur\([^\)]+\)/g,
+        val = /-?[^,\s-]+/g,
+        cssDot = "position:absolute;left:0;top:0;width:1px;height:1px",
+        zoom = 21600,
+        pathTypes = {path: 1, rect: 1, image: 1},
+        ovalTypes = {circle: 1, ellipse: 1},
+        path2vml = function (path) {
+            var total =  /[ahqstv]/ig,
+                command = R._pathToAbsolute;
+            Str(path).match(total) && (command = R._path2curve);
+            total = /[clmz]/g;
+            if (command == R._pathToAbsolute && !Str(path).match(total)) {
+                var res = Str(path).replace(bites, function (all, command, args) {
+                    var vals = [],
+                        isMove = command.toLowerCase() == "m",
+                        res = map[command];
+                    args.replace(val, function (value) {
+                        if (isMove && vals.length == 2) {
+                            res += vals + map[command == "m" ? "l" : "L"];
+                            vals = [];
+                        }
+                        vals.push(round(value * zoom));
+                    });
+                    return res + vals;
+                });
+                return res;
+            }
+            var pa = command(path), p, r;
+            res = [];
+            for (var i = 0, ii = pa.length; i < ii; i++) {
+                p = pa[i];
+                r = pa[i][0].toLowerCase();
+                r == "z" && (r = "x");
+                for (var j = 1, jj = p.length; j < jj; j++) {
+                    r += round(p[j] * zoom) + (j != jj - 1 ? "," : E);
+                }
+                res.push(r);
+            }
+            return res.join(S);
+        },
+        compensation = function (deg, dx, dy) {
+            var m = R.matrix();
+            m.rotate(-deg, .5, .5);
+            return {
+                dx: m.x(dx, dy),
+                dy: m.y(dx, dy)
+            };
+        },
+        setCoords = function (p, sx, sy, dx, dy, deg) {
+            var _ = p._,
+                m = p.matrix,
+                fillpos = _.fillpos,
+                o = p.node,
+                s = o.style,
+                y = 1,
+                flip = "",
+                dxdy,
+                kx = zoom / sx,
+                ky = zoom / sy;
+            s.visibility = "hidden";
+            if (!sx || !sy) {
+                return;
+            }
+            o.coordsize = abs(kx) + S + abs(ky);
+            s.rotation = deg * (sx * sy < 0 ? -1 : 1);
+            if (deg) {
+                var c = compensation(deg, dx, dy);
+                dx = c.dx;
+                dy = c.dy;
+            }
+            sx < 0 && (flip += "x");
+            sy < 0 && (flip += " y") && (y = -1);
+            s.flip = flip;
+            o.coordorigin = (dx * -kx) + S + (dy * -ky);
+            if (fillpos || _.fillsize) {
+                var fill = o.getElementsByTagName(fillString);
+                fill = fill && fill[0];
+                o.removeChild(fill);
+                if (fillpos) {
+                    c = compensation(deg, m.x(fillpos[0], fillpos[1]), m.y(fillpos[0], fillpos[1]));
+                    fill.position = c.dx * y + S + c.dy * y;
+                }
+                if (_.fillsize) {
+                    fill.size = _.fillsize[0] * abs(sx) + S + _.fillsize[1] * abs(sy);
+                }
+                o.appendChild(fill);
+            }
+            s.visibility = "visible";
+        };
+    R.toString = function () {
+        return  "Your browser doesn\u2019t support SVG. Falling down to VML.\nYou are running Rapha\xebl " + this.version;
+    };
+    var addArrow = function (o, value, isEnd) {
+        var values = Str(value).toLowerCase().split("-"),
+            se = isEnd ? "end" : "start",
+            i = values.length,
+            type = "classic",
+            w = "medium",
+            h = "medium";
+        while (i--) {
+            switch (values[i]) {
+                case "block":
+                case "classic":
+                case "oval":
+                case "diamond":
+                case "open":
+                case "none":
+                    type = values[i];
+                    break;
+                case "wide":
+                case "narrow": h = values[i]; break;
+                case "long":
+                case "short": w = values[i]; break;
+            }
+        }
+        var stroke = o.node.getElementsByTagName("stroke")[0];
+        stroke[se + "arrow"] = type;
+        stroke[se + "arrowlength"] = w;
+        stroke[se + "arrowwidth"] = h;
+    },
+    setFillAndStroke = function (o, params) {
+        // o.paper.canvas.style.display = "none";
+        o.attrs = o.attrs || {};
+        var node = o.node,
+            a = o.attrs,
+            s = node.style,
+            xy,
+            newpath = pathTypes[o.type] && (params.x != a.x || params.y != a.y || params.width != a.width || params.height != a.height || params.cx != a.cx || params.cy != a.cy || params.rx != a.rx || params.ry != a.ry || params.r != a.r),
+            isOval = ovalTypes[o.type] && (a.cx != params.cx || a.cy != params.cy || a.r != params.r || a.rx != params.rx || a.ry != params.ry),
+            res = o;
+
+
+        for (var par in params) if (params[has](par)) {
+            a[par] = params[par];
+        }
+        if (newpath) {
+            a.path = R._getPath[o.type](o);
+            o._.dirty = 1;
+        }
+        params.href && (node.href = params.href);
+        params.title && (node.title = params.title);
+        params.target && (node.target = params.target);
+        params.cursor && (s.cursor = params.cursor);
+        "blur" in params && o.blur(params.blur);
+        if (params.path && o.type == "path" || newpath) {
+            node.path = path2vml(~Str(a.path).toLowerCase().indexOf("r") ? R._pathToAbsolute(a.path) : a.path);
+            if (o.type == "image") {
+                o._.fillpos = [a.x, a.y];
+                o._.fillsize = [a.width, a.height];
+                setCoords(o, 1, 1, 0, 0, 0);
+            }
+        }
+        "transform" in params && o.transform(params.transform);
+        if (isOval) {
+            var cx = +a.cx,
+                cy = +a.cy,
+                rx = +a.rx || +a.r || 0,
+                ry = +a.ry || +a.r || 0;
+            node.path = R.format("ar{0},{1},{2},{3},{4},{1},{4},{1}x", round((cx - rx) * zoom), round((cy - ry) * zoom), round((cx + rx) * zoom), round((cy + ry) * zoom), round(cx * zoom));
+            o._.dirty = 1;
+        }
+        if ("clip-rect" in params) {
+            var rect = Str(params["clip-rect"]).split(separator);
+            if (rect.length == 4) {
+                rect[2] = +rect[2] + (+rect[0]);
+                rect[3] = +rect[3] + (+rect[1]);
+                var div = node.clipRect || R._g.doc.createElement("div"),
+                    dstyle = div.style;
+                dstyle.clip = R.format("rect({1}px {2}px {3}px {0}px)", rect);
+                if (!node.clipRect) {
+                    dstyle.position = "absolute";
+                    dstyle.top = 0;
+                    dstyle.left = 0;
+                    dstyle.width = o.paper.width + "px";
+                    dstyle.height = o.paper.height + "px";
+                    node.parentNode.insertBefore(div, node);
+                    div.appendChild(node);
+                    node.clipRect = div;
+                }
+            }
+            if (!params["clip-rect"]) {
+                node.clipRect && (node.clipRect.style.clip = "auto");
+            }
+        }
+        if (o.textpath) {
+            var textpathStyle = o.textpath.style;
+            params.font && (textpathStyle.font = params.font);
+            params["font-family"] && (textpathStyle.fontFamily = '"' + params["font-family"].split(",")[0].replace(/^['"]+|['"]+$/g, E) + '"');
+            params["font-size"] && (textpathStyle.fontSize = params["font-size"]);
+            params["font-weight"] && (textpathStyle.fontWeight = params["font-weight"]);
+            params["font-style"] && (textpathStyle.fontStyle = params["font-style"]);
+        }
+        if ("arrow-start" in params) {
+            addArrow(res, params["arrow-start"]);
+        }
+        if ("arrow-end" in params) {
+            addArrow(res, params["arrow-end"], 1);
+        }
+        if (params.opacity != null || 
+            params["stroke-width"] != null ||
+            params.fill != null ||
+            params.src != null ||
+            params.stroke != null ||
+            params["stroke-width"] != null ||
+            params["stroke-opacity"] != null ||
+            params["fill-opacity"] != null ||
+            params["stroke-dasharray"] != null ||
+            params["stroke-miterlimit"] != null ||
+            params["stroke-linejoin"] != null ||
+            params["stroke-linecap"] != null) {
+            var fill = node.getElementsByTagName(fillString),
+                newfill = false;
+            fill = fill && fill[0];
+            !fill && (newfill = fill = createNode(fillString));
+            if (o.type == "image" && params.src) {
+                fill.src = params.src;
+            }
+            params.fill && (fill.on = true);
+            if (fill.on == null || params.fill == "none" || params.fill === null) {
+                fill.on = false;
+            }
+            if (fill.on && params.fill) {
+                var isURL = Str(params.fill).match(R._ISURL);
+                if (isURL) {
+                    fill.parentNode == node && node.removeChild(fill);
+                    fill.rotate = true;
+                    fill.src = isURL[1];
+                    fill.type = "tile";
+                    var bbox = o.getBBox(1);
+                    fill.position = bbox.x + S + bbox.y;
+                    o._.fillpos = [bbox.x, bbox.y];
+
+                    R._preload(isURL[1], function () {
+                        o._.fillsize = [this.offsetWidth, this.offsetHeight];
+                    });
+                } else {
+                    fill.color = R.getRGB(params.fill).hex;
+                    fill.src = E;
+                    fill.type = "solid";
+                    if (R.getRGB(params.fill).error && (res.type in {circle: 1, ellipse: 1} || Str(params.fill).charAt() != "r") && addGradientFill(res, params.fill, fill)) {
+                        a.fill = "none";
+                        a.gradient = params.fill;
+                        fill.rotate = false;
+                    }
+                }
+            }
+            if ("fill-opacity" in params || "opacity" in params) {
+                var opacity = ((+a["fill-opacity"] + 1 || 2) - 1) * ((+a.opacity + 1 || 2) - 1) * ((+R.getRGB(params.fill).o + 1 || 2) - 1);
+                opacity = mmin(mmax(opacity, 0), 1);
+                fill.opacity = opacity;
+                if (fill.src) {
+                    fill.color = "none";
+                }
+            }
+            node.appendChild(fill);
+            var stroke = (node.getElementsByTagName("stroke") && node.getElementsByTagName("stroke")[0]),
+            newstroke = false;
+            !stroke && (newstroke = stroke = createNode("stroke"));
+            if ((params.stroke && params.stroke != "none") ||
+                params["stroke-width"] ||
+                params["stroke-opacity"] != null ||
+                params["stroke-dasharray"] ||
+                params["stroke-miterlimit"] ||
+                params["stroke-linejoin"] ||
+                params["stroke-linecap"]) {
+                stroke.on = true;
+            }
+            (params.stroke == "none" || params.stroke === null || stroke.on == null || params.stroke == 0 || params["stroke-width"] == 0) && (stroke.on = false);
+            var strokeColor = R.getRGB(params.stroke);
+            stroke.on && params.stroke && (stroke.color = strokeColor.hex);
+            opacity = ((+a["stroke-opacity"] + 1 || 2) - 1) * ((+a.opacity + 1 || 2) - 1) * ((+strokeColor.o + 1 || 2) - 1);
+            var width = (toFloat(params["stroke-width"]) || 1) * .75;
+            opacity = mmin(mmax(opacity, 0), 1);
+            params["stroke-width"] == null && (width = a["stroke-width"]);
+            params["stroke-width"] && (stroke.weight = width);
+            width && width < 1 && (opacity *= width) && (stroke.weight = 1);
+            stroke.opacity = opacity;
+        
+            params["stroke-linejoin"] && (stroke.joinstyle = params["stroke-linejoin"] || "miter");
+            stroke.miterlimit = params["stroke-miterlimit"] || 8;
+            params["stroke-linecap"] && (stroke.endcap = params["stroke-linecap"] == "butt" ? "flat" : params["stroke-linecap"] == "square" ? "square" : "round");
+            if ("stroke-dasharray" in params) {
+                var dasharray = {
+                    "-": "shortdash",
+                    ".": "shortdot",
+                    "-.": "shortdashdot",
+                    "-..": "shortdashdotdot",
+                    ". ": "dot",
+                    "- ": "dash",
+                    "--": "longdash",
+                    "- .": "dashdot",
+                    "--.": "longdashdot",
+                    "--..": "longdashdotdot"
+                };
+                stroke.dashstyle = dasharray[has](params["stroke-dasharray"]) ? dasharray[params["stroke-dasharray"]] : E;
+            }
+            newstroke && node.appendChild(stroke);
+        }
+        if (res.type == "text") {
+            res.paper.canvas.style.display = E;
+            var span = res.paper.span,
+                m = 100,
+                fontSize = a.font && a.font.match(/\d+(?:\.\d*)?(?=px)/);
+            s = span.style;
+            a.font && (s.font = a.font);
+            a["font-family"] && (s.fontFamily = a["font-family"]);
+            a["font-weight"] && (s.fontWeight = a["font-weight"]);
+            a["font-style"] && (s.fontStyle = a["font-style"]);
+            fontSize = toFloat(a["font-size"] || fontSize && fontSize[0]) || 10;
+            s.fontSize = fontSize * m + "px";
+            res.textpath.string && (span.innerHTML = Str(res.textpath.string).replace(/</g, "&#60;").replace(/&/g, "&#38;").replace(/\n/g, "<br>"));
+            var brect = span.getBoundingClientRect();
+            res.W = a.w = (brect.right - brect.left) / m;
+            res.H = a.h = (brect.bottom - brect.top) / m;
+            // res.paper.canvas.style.display = "none";
+            res.X = a.x;
+            res.Y = a.y + res.H / 2;
+
+            ("x" in params || "y" in params) && (res.path.v = R.format("m{0},{1}l{2},{1}", round(a.x * zoom), round(a.y * zoom), round(a.x * zoom) + 1));
+            var dirtyattrs = ["x", "y", "text", "font", "font-family", "font-weight", "font-style", "font-size"];
+            for (var d = 0, dd = dirtyattrs.length; d < dd; d++) if (dirtyattrs[d] in params) {
+                res._.dirty = 1;
+                break;
+            }
+        
+            // text-anchor emulation
+            switch (a["text-anchor"]) {
+                case "start":
+                    res.textpath.style["v-text-align"] = "left";
+                    res.bbx = res.W / 2;
+                break;
+                case "end":
+                    res.textpath.style["v-text-align"] = "right";
+                    res.bbx = -res.W / 2;
+                break;
+                default:
+                    res.textpath.style["v-text-align"] = "center";
+                    res.bbx = 0;
+                break;
+            }
+            res.textpath.style["v-text-kern"] = true;
+        }
+        // res.paper.canvas.style.display = E;
+    },
+    addGradientFill = function (o, gradient, fill) {
+        o.attrs = o.attrs || {};
+        var attrs = o.attrs,
+            pow = Math.pow,
+            opacity,
+            oindex,
+            type = "linear",
+            fxfy = ".5 .5";
+        o.attrs.gradient = gradient;
+        gradient = Str(gradient).replace(R._radial_gradient, function (all, fx, fy) {
+            type = "radial";
+            if (fx && fy) {
+                fx = toFloat(fx);
+                fy = toFloat(fy);
+                pow(fx - .5, 2) + pow(fy - .5, 2) > .25 && (fy = math.sqrt(.25 - pow(fx - .5, 2)) * ((fy > .5) * 2 - 1) + .5);
+                fxfy = fx + S + fy;
+            }
+            return E;
+        });
+        gradient = gradient.split(/\s*\-\s*/);
+        if (type == "linear") {
+            var angle = gradient.shift();
+            angle = -toFloat(angle);
+            if (isNaN(angle)) {
+                return null;
+            }
+        }
+        var dots = R._parseDots(gradient);
+        if (!dots) {
+            return null;
+        }
+        o = o.shape || o.node;
+        if (dots.length) {
+            o.removeChild(fill);
+            fill.on = true;
+            fill.method = "none";
+            fill.color = dots[0].color;
+            fill.color2 = dots[dots.length - 1].color;
+            var clrs = [];
+            for (var i = 0, ii = dots.length; i < ii; i++) {
+                dots[i].offset && clrs.push(dots[i].offset + S + dots[i].color);
+            }
+            fill.colors = clrs.length ? clrs.join() : "0% " + fill.color;
+            if (type == "radial") {
+                fill.type = "gradientTitle";
+                fill.focus = "100%";
+                fill.focussize = "0 0";
+                fill.focusposition = fxfy;
+                fill.angle = 0;
+            } else {
+                // fill.rotate= true;
+                fill.type = "gradient";
+                fill.angle = (270 - angle) % 360;
+            }
+            o.appendChild(fill);
+        }
+        return 1;
+    },
+    Element = function (node, vml) {
+        this[0] = this.node = node;
+        node.raphael = true;
+        this.id = R._oid++;
+        node.raphaelid = this.id;
+        this.X = 0;
+        this.Y = 0;
+        this.attrs = {};
+        this.paper = vml;
+        this.matrix = R.matrix();
+        this._ = {
+            transform: [],
+            sx: 1,
+            sy: 1,
+            dx: 0,
+            dy: 0,
+            deg: 0,
+            dirty: 1,
+            dirtyT: 1
+        };
+        !vml.bottom && (vml.bottom = this);
+        this.prev = vml.top;
+        vml.top && (vml.top.next = this);
+        vml.top = this;
+        this.next = null;
+    };
+    var elproto = R.el;
+
+    Element.prototype = elproto;
+    elproto.constructor = Element;
+    elproto.transform = function (tstr) {
+        if (tstr == null) {
+            return this._.transform;
+        }
+        var vbs = this.paper._viewBoxShift,
+            vbt = vbs ? "s" + [vbs.scale, vbs.scale] + "-1-1t" + [vbs.dx, vbs.dy] : E,
+            oldt;
+        if (vbs) {
+            oldt = tstr = Str(tstr).replace(/\.{3}|\u2026/g, this._.transform || E);
+        }
+        R._extractTransform(this, vbt + tstr);
+        var matrix = this.matrix.clone(),
+            skew = this.skew,
+            o = this.node,
+            split,
+            isGrad = ~Str(this.attrs.fill).indexOf("-"),
+            isPatt = !Str(this.attrs.fill).indexOf("url(");
+        matrix.translate(1, 1);
+        if (isPatt || isGrad || this.type == "image") {
+            skew.matrix = "1 0 0 1";
+            skew.offset = "0 0";
+            split = matrix.split();
+            if ((isGrad && split.noRotation) || !split.isSimple) {
+                o.style.filter = matrix.toFilter();
+                var bb = this.getBBox(),
+                    bbt = this.getBBox(1),
+                    dx = bb.x - bbt.x,
+                    dy = bb.y - bbt.y;
+                o.coordorigin = (dx * -zoom) + S + (dy * -zoom);
+                setCoords(this, 1, 1, dx, dy, 0);
+            } else {
+                o.style.filter = E;
+                setCoords(this, split.scalex, split.scaley, split.dx, split.dy, split.rotate);
+            }
+        } else {
+            o.style.filter = E;
+            skew.matrix = Str(matrix);
+            skew.offset = matrix.offset();
+        }
+        oldt && (this._.transform = oldt);
+        return this;
+    };
+    elproto.rotate = function (deg, cx, cy) {
+        if (this.removed) {
+            return this;
+        }
+        if (deg == null) {
+            return;
+        }
+        deg = Str(deg).split(separator);
+        if (deg.length - 1) {
+            cx = toFloat(deg[1]);
+            cy = toFloat(deg[2]);
+        }
+        deg = toFloat(deg[0]);
+        (cy == null) && (cx = cy);
+        if (cx == null || cy == null) {
+            var bbox = this.getBBox(1);
+            cx = bbox.x + bbox.width / 2;
+            cy = bbox.y + bbox.height / 2;
+        }
+        this._.dirtyT = 1;
+        this.transform(this._.transform.concat([["r", deg, cx, cy]]));
+        return this;
+    };
+    elproto.translate = function (dx, dy) {
+        if (this.removed) {
+            return this;
+        }
+        dx = Str(dx).split(separator);
+        if (dx.length - 1) {
+            dy = toFloat(dx[1]);
+        }
+        dx = toFloat(dx[0]) || 0;
+        dy = +dy || 0;
+        if (this._.bbox) {
+            this._.bbox.x += dx;
+            this._.bbox.y += dy;
+        }
+        this.transform(this._.transform.concat([["t", dx, dy]]));
+        return this;
+    };
+    elproto.scale = function (sx, sy, cx, cy) {
+        if (this.removed) {
+            return this;
+        }
+        sx = Str(sx).split(separator);
+        if (sx.length - 1) {
+            sy = toFloat(sx[1]);
+            cx = toFloat(sx[2]);
+            cy = toFloat(sx[3]);
+            isNaN(cx) && (cx = null);
+            isNaN(cy) && (cy = null);
+        }
+        sx = toFloat(sx[0]);
+        (sy == null) && (sy = sx);
+        (cy == null) && (cx = cy);
+        if (cx == null || cy == null) {
+            var bbox = this.getBBox(1);
+        }
+        cx = cx == null ? bbox.x + bbox.width / 2 : cx;
+        cy = cy == null ? bbox.y + bbox.height / 2 : cy;
+    
+        this.transform(this._.transform.concat([["s", sx, sy, cx, cy]]));
+        this._.dirtyT = 1;
+        return this;
+    };
+    elproto.hide = function () {
+        !this.removed && (this.node.style.display = "none");
+        return this;
+    };
+    elproto.show = function () {
+        !this.removed && (this.node.style.display = E);
+        return this;
+    };
+    elproto._getBBox = function () {
+        if (this.removed) {
+            return {};
+        }
+        return {
+            x: this.X + (this.bbx || 0) - this.W / 2,
+            y: this.Y - this.H,
+            width: this.W,
+            height: this.H
+        };
+    };
+    elproto.remove = function () {
+        if (this.removed || !this.node.parentNode) {
+            return;
+        }
+        this.paper.__set__ && this.paper.__set__.exclude(this);
+        R.eve.unbind("raphael.*.*." + this.id);
+        R._tear(this, this.paper);
+        this.node.parentNode.removeChild(this.node);
+        this.shape && this.shape.parentNode.removeChild(this.shape);
+        for (var i in this) {
+            this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null;
+        }
+        this.removed = true;
+    };
+    elproto.attr = function (name, value) {
+        if (this.removed) {
+            return this;
+        }
+        if (name == null) {
+            var res = {};
+            for (var a in this.attrs) if (this.attrs[has](a)) {
+                res[a] = this.attrs[a];
+            }
+            res.gradient && res.fill == "none" && (res.fill = res.gradient) && delete res.gradient;
+            res.transform = this._.transform;
+            return res;
+        }
+        if (value == null && R.is(name, "string")) {
+            if (name == fillString && this.attrs.fill == "none" && this.attrs.gradient) {
+                return this.attrs.gradient;
+            }
+            var names = name.split(separator),
+                out = {};
+            for (var i = 0, ii = names.length; i < ii; i++) {
+                name = names[i];
+                if (name in this.attrs) {
+                    out[name] = this.attrs[name];
+                } else if (R.is(this.paper.customAttributes[name], "function")) {
+                    out[name] = this.paper.customAttributes[name].def;
+                } else {
+                    out[name] = R._availableAttrs[name];
+                }
+            }
+            return ii - 1 ? out : out[names[0]];
+        }
+        if (this.attrs && value == null && R.is(name, "array")) {
+            out = {};
+            for (i = 0, ii = name.length; i < ii; i++) {
+                out[name[i]] = this.attr(name[i]);
+            }
+            return out;
+        }
+        var params;
+        if (value != null) {
+            params = {};
+            params[name] = value;
+        }
+        value == null && R.is(name, "object") && (params = name);
+        for (var key in params) {
+            eve("raphael.attr." + key + "." + this.id, this, params[key]);
+        }
+        if (params) {
+            for (key in this.paper.customAttributes) if (this.paper.customAttributes[has](key) && params[has](key) && R.is(this.paper.customAttributes[key], "function")) {
+                var par = this.paper.customAttributes[key].apply(this, [].concat(params[key]));
+                this.attrs[key] = params[key];
+                for (var subkey in par) if (par[has](subkey)) {
+                    params[subkey] = par[subkey];
+                }
+            }
+            // this.paper.canvas.style.display = "none";
+            if (params.text && this.type == "text") {
+                this.textpath.string = params.text;
+            }
+            setFillAndStroke(this, params);
+            // this.paper.canvas.style.display = E;
+        }
+        return this;
+    };
+    elproto.toFront = function () {
+        !this.removed && this.node.parentNode.appendChild(this.node);
+        this.paper && this.paper.top != this && R._tofront(this, this.paper);
+        return this;
+    };
+    elproto.toBack = function () {
+        if (this.removed) {
+            return this;
+        }
+        if (this.node.parentNode.firstChild != this.node) {
+            this.node.parentNode.insertBefore(this.node, this.node.parentNode.firstChild);
+            R._toback(this, this.paper);
+        }
+        return this;
+    };
+    elproto.insertAfter = function (element) {
+        if (this.removed) {
+            return this;
+        }
+        if (element.constructor == R.st.constructor) {
+            element = element[element.length - 1];
+        }
+        if (element.node.nextSibling) {
+            element.node.parentNode.insertBefore(this.node, element.node.nextSibling);
+        } else {
+            element.node.parentNode.appendChild(this.node);
+        }
+        R._insertafter(this, element, this.paper);
+        return this;
+    };
+    elproto.insertBefore = function (element) {
+        if (this.removed) {
+            return this;
+        }
+        if (element.constructor == R.st.constructor) {
+            element = element[0];
+        }
+        element.node.parentNode.insertBefore(this.node, element.node);
+        R._insertbefore(this, element, this.paper);
+        return this;
+    };
+    elproto.blur = function (size) {
+        var s = this.node.runtimeStyle,
+            f = s.filter;
+        f = f.replace(blurregexp, E);
+        if (+size !== 0) {
+            this.attrs.blur = size;
+            s.filter = f + S + ms + ".Blur(pixelradius=" + (+size || 1.5) + ")";
+            s.margin = R.format("-{0}px 0 0 -{0}px", round(+size || 1.5));
+        } else {
+            s.filter = f;
+            s.margin = 0;
+            delete this.attrs.blur;
+        }
+        return this;
+    };
+
+    R._engine.path = function (pathString, vml) {
+        var el = createNode("shape");
+        el.style.cssText = cssDot;
+        el.coordsize = zoom + S + zoom;
+        el.coordorigin = vml.coordorigin;
+        var p = new Element(el, vml),
+            attr = {fill: "none", stroke: "#000"};
+        pathString && (attr.path = pathString);
+        p.type = "path";
+        p.path = [];
+        p.Path = E;
+        setFillAndStroke(p, attr);
+        vml.canvas.appendChild(el);
+        var skew = createNode("skew");
+        skew.on = true;
+        el.appendChild(skew);
+        p.skew = skew;
+        p.transform(E);
+        return p;
+    };
+    R._engine.rect = function (vml, x, y, w, h, r) {
+        var path = R._rectPath(x, y, w, h, r),
+            res = vml.path(path),
+            a = res.attrs;
+        res.X = a.x = x;
+        res.Y = a.y = y;
+        res.W = a.width = w;
+        res.H = a.height = h;
+        a.r = r;
+        a.path = path;
+        res.type = "rect";
+        return res;
+    };
+    R._engine.ellipse = function (vml, x, y, rx, ry) {
+        var res = vml.path(),
+            a = res.attrs;
+        res.X = x - rx;
+        res.Y = y - ry;
+        res.W = rx * 2;
+        res.H = ry * 2;
+        res.type = "ellipse";
+        setFillAndStroke(res, {
+            cx: x,
+            cy: y,
+            rx: rx,
+            ry: ry
+        });
+        return res;
+    };
+    R._engine.circle = function (vml, x, y, r) {
+        var res = vml.path(),
+            a = res.attrs;
+        res.X = x - r;
+        res.Y = y - r;
+        res.W = res.H = r * 2;
+        res.type = "circle";
+        setFillAndStroke(res, {
+            cx: x,
+            cy: y,
+            r: r
+        });
+        return res;
+    };
+    R._engine.image = function (vml, src, x, y, w, h) {
+        var path = R._rectPath(x, y, w, h),
+            res = vml.path(path).attr({stroke: "none"}),
+            a = res.attrs,
+            node = res.node,
+            fill = node.getElementsByTagName(fillString)[0];
+        a.src = src;
+        res.X = a.x = x;
+        res.Y = a.y = y;
+        res.W = a.width = w;
+        res.H = a.height = h;
+        a.path = path;
+        res.type = "image";
+        fill.parentNode == node && node.removeChild(fill);
+        fill.rotate = true;
+        fill.src = src;
+        fill.type = "tile";
+        res._.fillpos = [x, y];
+        res._.fillsize = [w, h];
+        node.appendChild(fill);
+        setCoords(res, 1, 1, 0, 0, 0);
+        return res;
+    };
+    R._engine.text = function (vml, x, y, text) {
+        var el = createNode("shape"),
+            path = createNode("path"),
+            o = createNode("textpath");
+        x = x || 0;
+        y = y || 0;
+        text = text || "";
+        path.v = R.format("m{0},{1}l{2},{1}", round(x * zoom), round(y * zoom), round(x * zoom) + 1);
+        path.textpathok = true;
+        o.string = Str(text);
+        o.on = true;
+        el.style.cssText = cssDot;
+        el.coordsize = zoom + S + zoom;
+        el.coordorigin = "0 0";
+        var p = new Element(el, vml),
+            attr = {
+                fill: "#000",
+                stroke: "none",
+                font: R._availableAttrs.font,
+                text: text
+            };
+        p.shape = el;
+        p.path = path;
+        p.textpath = o;
+        p.type = "text";
+        p.attrs.text = Str(text);
+        p.attrs.x = x;
+        p.attrs.y = y;
+        p.attrs.w = 1;
+        p.attrs.h = 1;
+        setFillAndStroke(p, attr);
+        el.appendChild(o);
+        el.appendChild(path);
+        vml.canvas.appendChild(el);
+        var skew = createNode("skew");
+        skew.on = true;
+        el.appendChild(skew);
+        p.skew = skew;
+        p.transform(E);
+        return p;
+    };
+    R._engine.setSize = function (width, height) {
+        var cs = this.canvas.style;
+        this.width = width;
+        this.height = height;
+        width == +width && (width += "px");
+        height == +height && (height += "px");
+        cs.width = width;
+        cs.height = height;
+        cs.clip = "rect(0 " + width + " " + height + " 0)";
+        if (this._viewBox) {
+            R._engine.setViewBox.apply(this, this._viewBox);
+        }
+        return this;
+    };
+    R._engine.setViewBox = function (x, y, w, h, fit) {
+        R.eve("raphael.setViewBox", this, this._viewBox, [x, y, w, h, fit]);
+        var width = this.width,
+            height = this.height,
+            size = 1 / mmax(w / width, h / height),
+            H, W;
+        if (fit) {
+            H = height / h;
+            W = width / w;
+            if (w * H < width) {
+                x -= (width - w * H) / 2 / H;
+            }
+            if (h * W < height) {
+                y -= (height - h * W) / 2 / W;
+            }
+        }
+        this._viewBox = [x, y, w, h, !!fit];
+        this._viewBoxShift = {
+            dx: -x,
+            dy: -y,
+            scale: size
+        };
+        this.forEach(function (el) {
+            el.transform("...");
+        });
+        return this;
+    };
+    var createNode;
+    R._engine.initWin = function (win) {
+            var doc = win.document;
+            doc.createStyleSheet().addRule(".rvml", "behavior:url(#default#VML)");
+            try {
+                !doc.namespaces.rvml && doc.namespaces.add("rvml", "urn:schemas-microsoft-com:vml");
+                createNode = function (tagName) {
+                    return doc.createElement('<rvml:' + tagName + ' class="rvml">');
+                };
+            } catch (e) {
+                createNode = function (tagName) {
+                    return doc.createElement('<' + tagName + ' xmlns="urn:schemas-microsoft.com:vml" class="rvml">');
+                };
+            }
+        };
+    R._engine.initWin(R._g.win);
+    R._engine.create = function () {
+        var con = R._getContainer.apply(0, arguments),
+            container = con.container,
+            height = con.height,
+            s,
+            width = con.width,
+            x = con.x,
+            y = con.y;
+        if (!container) {
+            throw new Error("VML container not found.");
+        }
+        var res = new R._Paper,
+            c = res.canvas = R._g.doc.createElement("div"),
+            cs = c.style;
+        x = x || 0;
+        y = y || 0;
+        width = width || 512;
+        height = height || 342;
+        res.width = width;
+        res.height = height;
+        width == +width && (width += "px");
+        height == +height && (height += "px");
+        res.coordsize = zoom * 1e3 + S + zoom * 1e3;
+        res.coordorigin = "0 0";
+        res.span = R._g.doc.createElement("span");
+        res.span.style.cssText = "position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;";
+        c.appendChild(res.span);
+        cs.cssText = R.format("top:0;left:0;width:{0};height:{1};display:inline-block;position:relative;clip:rect(0 {0} {1} 0);overflow:hidden", width, height);
+        if (container == 1) {
+            R._g.doc.body.appendChild(c);
+            cs.left = x + "px";
+            cs.top = y + "px";
+            cs.position = "absolute";
+        } else {
+            if (container.firstChild) {
+                container.insertBefore(c, container.firstChild);
+            } else {
+                container.appendChild(c);
+            }
+        }
+        res.renderfix = function () {};
+        return res;
+    };
+    R.prototype.clear = function () {
+        R.eve("raphael.clear", this);
+        this.canvas.innerHTML = E;
+        this.span = R._g.doc.createElement("span");
+        this.span.style.cssText = "position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;display:inline;";
+        this.canvas.appendChild(this.span);
+        this.bottom = this.top = null;
+    };
+    R.prototype.remove = function () {
+        R.eve("raphael.remove", this);
+        this.canvas.parentNode.removeChild(this.canvas);
+        for (var i in this) {
+            this[i] = typeof this[i] == "function" ? R._removedFactory(i) : null;
+        }
+        return true;
+    };
+
+    var setproto = R.st;
+    for (var method in elproto) if (elproto[has](method) && !setproto[has](method)) {
+        setproto[method] = (function (methodname) {
+            return function () {
+                var arg = arguments;
+                return this.forEach(function (el) {
+                    el[methodname].apply(el, arg);
+                });
+            };
+        })(method);
+    }
+})();
+
+    // EXPOSE
+    // SVG and VML are appended just before the EXPOSE line
+    // Even with AMD, Raphael should be defined globally
+    oldRaphael.was ? (g.win.Raphael = R) : (Raphael = R);
+
+    return R;
+}));
diff --git a/web/src/main/resources/js/routie.min.js b/web/src/main/resources/js/routie.min.js
new file mode 100644
index 000000000..d9fb5b3d1
--- /dev/null
+++ b/web/src/main/resources/js/routie.min.js
@@ -0,0 +1,8 @@
+/*!
+ * routie - a tiny hash router
+ * v0.3.2
+ * http://projects.jga.me/routie
+ * copyright Greg Allen 2013
+ * MIT License
+*/
+(function(n){var e=[],t={},r="routie",o=n[r],i=function(n,e){this.name=e,this.path=n,this.keys=[],this.fns=[],this.params={},this.regex=a(this.path,this.keys,!1,!1)};i.prototype.addHandler=function(n){this.fns.push(n)},i.prototype.removeHandler=function(n){for(var e=0,t=this.fns.length;t>e;e++){var r=this.fns[e];if(n==r)return this.fns.splice(e,1),void 0}},i.prototype.run=function(n){for(var e=0,t=this.fns.length;t>e;e++)this.fns[e].apply(this,n)},i.prototype.match=function(n,e){var t=this.regex.exec(n);if(!t)return!1;for(var r=1,o=t.length;o>r;++r){var i=this.keys[r-1],a="string"==typeof t[r]?decodeURIComponent(t[r]):t[r];i&&(this.params[i.name]=a),e.push(a)}return!0},i.prototype.toURL=function(n){var e=this.path;for(var t in n)e=e.replace("/:"+t,"/"+n[t]);if(e=e.replace(/\/:.*\?/g,"/").replace(/\?/g,""),-1!=e.indexOf(":"))throw Error("missing parameters for url: "+e);return e};var a=function(n,e,t,r){return n instanceof RegExp?n:(n instanceof Array&&(n="("+n.join("|")+")"),n=n.concat(r?"":"/?").replace(/\/\(/g,"(?:/").replace(/\+/g,"__plus__").replace(/(\/)?(\.)?:(\w+)(?:(\(.*?\)))?(\?)?/g,function(n,t,r,o,i,a){return e.push({name:o,optional:!!a}),t=t||"",""+(a?"":t)+"(?:"+(a?t:"")+(r||"")+(i||r&&"([^/.]+?)"||"([^/]+?)")+")"+(a||"")}).replace(/([\/.])/g,"\\$1").replace(/__plus__/g,"(.+)").replace(/\*/g,"(.*)"),RegExp("^"+n+"$",t?"":"i"))},s=function(n,r){var o=n.split(" "),a=2==o.length?o[0]:null;n=2==o.length?o[1]:o[0],t[n]||(t[n]=new i(n,a),e.push(t[n])),t[n].addHandler(r)},h=function(n,e){if("function"==typeof e)s(n,e),h.reload();else if("object"==typeof n){for(var t in n)s(t,n[t]);h.reload()}else e===void 0&&h.navigate(n)};h.lookup=function(n,t){for(var r=0,o=e.length;o>r;r++){var i=e[r];if(i.name==n)return i.toURL(t)}},h.remove=function(n,e){var r=t[n];r&&r.removeHandler(e)},h.removeAll=function(){t={},e=[]},h.navigate=function(n,e){e=e||{};var t=e.silent||!1;t&&l(),setTimeout(function(){window.location.hash=n,t&&setTimeout(function(){p()},1)},1)},h.noConflict=function(){return n[r]=o,h};var f=function(){return window.location.hash.substring(1)},c=function(n,e){var t=[];return e.match(n,t)?(e.run(t),!0):!1},u=h.reload=function(){for(var n=f(),t=0,r=e.length;r>t;t++){var o=e[t];if(c(n,o))return}},p=function(){n.addEventListener?n.addEventListener("hashchange",u,!1):n.attachEvent("onhashchange",u)},l=function(){n.removeEventListener?n.removeEventListener("hashchange",u):n.detachEvent("onhashchange",u)};p(),n[r]=h})(window);
\ No newline at end of file
diff --git a/web/src/main/scala/coursier/web/Backend.scala b/web/src/main/scala/coursier/web/Backend.scala
new file mode 100644
index 000000000..4b1cb1d2e
--- /dev/null
+++ b/web/src/main/scala/coursier/web/Backend.scala
@@ -0,0 +1,535 @@
+package coursier
+package web
+
+import coursier.core.{Resolver, Logger, Remote}
+import japgolly.scalajs.react.vdom.{TagMod, Attr}
+import japgolly.scalajs.react.vdom.Attrs.dangerouslySetInnerHtml
+import japgolly.scalajs.react.{ReactKeyboardEventI, ReactEventI, ReactComponentB, BackendScope}
+import japgolly.scalajs.react.vdom.prefix_<^._
+import scala.scalajs.concurrent.JSExecutionContext.Implicits.queue
+import org.scalajs.jquery.jQuery
+
+import scala.scalajs.js
+import js.Dynamic.{global => g}
+
+case class ResolutionOptions(followOptional: Boolean = false,
+                             keepTest: Boolean = false)
+
+case class State(modules: Seq[Dependency],
+                 repositories: Seq[Remote],
+                 options: ResolutionOptions,
+                 resolutionOpt: Option[Resolution],
+                 editModuleIdx: Int,
+                 resolving: Boolean,
+                 reverseTree: Boolean,
+                 log: Seq[String])
+
+class Backend($: BackendScope[Unit, State]) {
+  def updateDepGraph(resolution: Resolution) = {
+    println("Rendering canvas")
+
+    val graph = js.Dynamic.newInstance(g.Graph)()
+
+    var nodes = Set.empty[String]
+    def addNode(name: String) =
+      if (!nodes(name)) {
+        graph.addNode(name)
+        nodes += name
+      }
+
+    for {
+      ((org, name, scope), par) <- resolution.reverseDependenciesAndExclusions.toList
+      from = s"$org:$name:${scope.name}"
+      _ = addNode(from)
+      ((parOrg, parName, parScope), _) <- par
+      to = s"$parOrg:$parName:${parScope.name}"
+      _ = addNode(to)
+    } {
+      graph.addEdge(from, to)
+    }
+
+    val layouter = js.Dynamic.newInstance(g.Graph.Layout.Spring)(graph)
+    layouter.layout()
+
+    val width = jQuery("#dependencies").width()
+    val height = math.max(jQuery("#dependencies").height().asInstanceOf[Int], 400)
+
+    println(s"width: $width, height: $height")
+
+    jQuery("#depgraphcanvas").html("") //empty()
+
+    val renderer = js.Dynamic.newInstance(g.Graph.Renderer.Raphael)("depgraphcanvas", graph, width, height)
+    renderer.draw()
+    println("Rendered canvas")
+  }
+
+  def updateDepGraphBtn(resolution: Resolution)(e: ReactEventI) = {
+    updateDepGraph(resolution)
+  }
+
+  def updateTree(resolution: Resolution, target: String, reverse: Boolean) = {
+    def depsOf(dep: Dependency) =
+      resolution.projectsCache.get(dep.module).toSeq.flatMap(t => Resolver.finalDependencies(dep, t._2).filter(resolution.filter getOrElse Resolver.defaultFilter))
+
+    lazy val reverseDeps = {
+      var m = Map.empty[Module, Seq[Dependency]]
+
+      for {
+        dep <- resolution.dependencies
+        trDep <- depsOf(dep)
+      } {
+        m += trDep.module -> (m.getOrElse(trDep.module, Nil) :+ dep)
+      }
+
+      m
+    }
+
+    def tree(dep: Dependency): js.Dictionary[js.Any] =
+      js.Dictionary(Seq(
+        "text" -> (s"${dep.module}": js.Any)
+      ) ++ {
+        val deps = if (reverse) reverseDeps.getOrElse(dep.module, Nil) else depsOf(dep)
+        if (deps.isEmpty) Seq()
+        else Seq("nodes" -> js.Array(deps.map(tree): _*))
+      }: _*)
+
+    println(resolution.dependencies.toList.map(tree).map(js.JSON.stringify(_)))
+    g.$(target).treeview(js.Dictionary("data" -> js.Array(resolution.dependencies.toList.map(tree): _*)))
+  }
+
+  def resolve(action: => Unit = ()) = {
+    g.$("#resLogTab a:last").tab("show")
+    $.modState(_.copy(resolving = true, log = Nil))
+
+    val logger: Logger = new Logger {
+      def fetched(url: String) = {
+        println(s"Fetching $url")
+        $.modState(s => s.copy(log = s"Fetching $url" +: s.log))
+      }
+      def fetching(url: String) = {
+        println(s"Fetched $url")
+        $.modState(s => s.copy(log = s"Fetched $url" +: s.log))
+      }
+      def other(url: String, msg: String) = {
+        println(s"$url: $msg")
+        $.modState(s => s.copy(log = s"$url: $msg" +: s.log))
+      }
+    }
+
+    val s = $.state
+    val task = coursier.resolve(
+      s.modules.toSet,
+      fetchFrom(s.repositories.map(_.copy(logger = Some(logger)))),
+      filter = Some(dep => (s.options.followOptional || !dep.optional) && (s.options.keepTest || dep.scope != Scope.Test))
+    )
+
+    task.runF.foreach { res: Resolution =>
+      $.modState{ s => updateDepGraph(res); updateTree(res, "#deptree", reverse = s.reverseTree); s.copy(resolutionOpt = Some(res), resolving = false)}
+      g.$("#resResTab a:last").tab("show")
+    }
+  }
+  def handleResolve(e: ReactEventI) = {
+    println(s"Resolving")
+    e.preventDefault()
+    jQuery("#results").css("display", "block")
+    resolve()
+  }
+
+  def clearLog(e: ReactEventI) = {
+    $.modState(_.copy(log = Nil))
+  }
+
+  def toggleReverseTree(e: ReactEventI) = {
+    $.modState{ s =>
+      for (res <- s.resolutionOpt)
+        updateTree(res, "#deptree", reverse = !s.reverseTree)
+      s.copy(reverseTree = !s.reverseTree)
+    }
+  }
+
+  def editModule(idx: Int)(e: ReactEventI) = {
+    e.preventDefault()
+    $.modState(_.copy(editModuleIdx = idx))
+  }
+
+  def removeModule(idx: Int)(e: ReactEventI) = {
+    e.preventDefault()
+    $.modState(s => s.copy(modules = s.modules.zipWithIndex.filter(_._2 != idx).map(_._1)))
+  }
+
+  def updateModule(moduleIdx: Int, update: (Dependency, String) => Dependency)(e: ReactEventI) = {
+    if (moduleIdx >= 0) {
+      $.modState{ state =>
+        val dep = state.modules(moduleIdx)
+        state.copy(modules = state.modules.updated(moduleIdx, update(dep, e.target.value)))
+      }
+    }
+  }
+
+  def addModule(e: ReactEventI) = {
+    e.preventDefault()
+    $.modState{ state =>
+      val modules = state.modules :+ Dependency(Module("", "", ""))
+      println(s"Modules:\n${modules.mkString("\n")}")
+      state.copy(modules = modules, editModuleIdx = modules.length - 1)
+    }
+  }
+
+  object options {
+    def toggleOptional(e: ReactEventI) = {
+      $.modState(s => s.copy(options = s.options.copy(followOptional = !s.options.followOptional)))
+    }
+    def toggleTest(e: ReactEventI) = {
+      $.modState(s => s.copy(options = s.options.copy(keepTest = !s.options.keepTest)))
+    }
+  }
+}
+
+object App {
+
+  lazy val arbor = g.arbor
+
+  val resultDependencies = ReactComponentB[Resolution]("Result")
+    .render{ res =>
+      def depItem(dep: Dependency) =
+        <.tr(
+          ^.`class` := (if (res.errors.contains(dep.module)) "danger" else ""),
+          <.td(dep.module.organization),
+          <.td(dep.module.name),
+          <.td(dep.module.version),
+          <.td(Seq[Seq[TagMod]](
+            if (dep.scope == Scope.Compile) Seq() else Seq(<.span(^.`class` := "label label-info", dep.scope.name)),
+            if (dep.`type`.isEmpty || dep.`type` == "jar") Seq() else Seq(<.span(^.`class` := "label label-info", dep.`type`)),
+            if (dep.classifier.isEmpty) Seq() else Seq(<.span(^.`class` := "label label-info", dep.classifier)),
+            if (dep.optional) Seq(<.span(^.`class` := "label label-info", dep.classifier)) else Seq()
+          )),
+         <.td(Seq[Seq[TagMod]](
+           res.projectsCache.get(dep.module) match {
+             case Some((repo: Remote, _)) =>
+               // FIXME Maven specific, generalize if/when adding support for Ivy
+               val relPath =
+                 dep.module.organization.split('.').toSeq ++ Seq(
+                   dep.module.name,
+                   dep.module.version,
+                   s"${dep.module.name}-${dep.module.version}"
+                 )
+
+               Seq(
+                 <.a(^.href := s"${repo.base}${relPath.mkString("/")}.pom",
+                   <.span(^.`class` := "label label-info", "POM")
+                 ),
+                 <.a(^.href := s"${repo.base}${relPath.mkString("/")}.jar",
+                   <.span(^.`class` := "label label-info", "JAR")
+                 )
+               )
+
+             case _ => Seq()
+           }
+         ))
+        )
+
+      val sortedDeps = res.dependencies.toList
+        .sortBy(dep => coursier.core.Module.unapply(dep.module).get)
+
+      <.table(^.`class` := "table",
+        <.thead(
+          <.tr(
+            <.th("Organization"),
+            <.th("Name"),
+            <.th("Version"),
+            <.th("Extra"),
+            <.th("Links")
+          )
+        ),
+        <.tbody(
+          sortedDeps.map(depItem)
+        )
+//        <.div(dangerouslySetInnerHtml("<script>$(function () {  $('[data-toggle=\"popover\"]').popover() })</script>"))
+      )
+    }
+    .build
+
+  object icon {
+    def apply(id: String) = <.span(^.`class` := s"glyphicon glyphicon-$id", ^.aria.hidden := "true")
+    def ok = apply("ok")
+    def edit = apply("pencil")
+    def remove = apply("remove")
+  }
+
+  val moduleEditModal = ReactComponentB[(Module, Int, Backend)]("EditModule")
+    .render{ P =>
+      val (module, moduleIdx, backend) = P
+      <.div(^.`class` := "modal fade", ^.id := "moduleEdit", ^.role := "dialog", ^.aria.labelledby := "moduleEditTitle",
+        <.div(^.`class` := "modal-dialog", <.div(^.`class` := "modal-content",
+          <.div(^.`class` := "modal-header",
+            <.button(^.`type` := "button", ^.`class` := "close", Attr("data-dismiss") := "modal", ^.aria.label := "Close",
+              <.span(^.aria.hidden := "true", dangerouslySetInnerHtml("&times;"))
+            ),
+            <.h4(^.`class` := "modal-title", ^.id := "moduleEditTitle", "Dependency")
+          ),
+          <.div(^.`class` := "modal-body",
+            <.form(
+              <.div(^.`class` := "form-group",
+                <.label(^.`for` := "inputOrganization", "Organization"),
+                <.input(^.`class` := "form-control", ^.id := "inputOrganization", ^.placeholder := "Organization",
+                  ^.onChange ==> backend.updateModule(moduleIdx, (dep, value) => dep.copy(module = dep.module.copy(organization = value))),
+                  ^.value := module.organization
+                )
+              ),
+              <.div(^.`class` := "form-group",
+                <.label(^.`for` := "inputName", "Name"),
+                <.input(^.`class` := "form-control", ^.id := "inputName", ^.placeholder := "Name",
+                  ^.onChange ==> backend.updateModule(moduleIdx, (dep, value) => dep.copy(module = dep.module.copy(name = value))),
+                  ^.value := module.name
+                )
+              ),
+              <.div(^.`class` := "form-group",
+                <.label(^.`for` := "inputVersion", "Version"),
+                <.input(^.`class` := "form-control", ^.id := "inputVersion", ^.placeholder := "Version",
+                  ^.onChange ==> backend.updateModule(moduleIdx, (dep, value) => dep.copy(module = dep.module.copy(version = value))),
+                  ^.value := module.version
+                )
+              ),
+              <.div(^.`class` := "modal-footer",
+                <.button(^.`type` := "submit", ^.`class` := "btn btn-primary", Attr("data-dismiss") := "modal", "Done")
+              )
+            )
+          )
+        ))
+      )
+    }
+    .build
+
+  def dependenciesTable(name: String) = ReactComponentB[(Seq[Dependency], Int, Backend)](name)
+    .render{ P =>
+      val (deps, editModuleIdx, backend) = P
+
+      def depItem(dep: Dependency, idx: Int) =
+        <.tr(
+          <.td(dep.module.organization),
+          <.td(dep.module.name),
+          <.td(dep.module.version),
+          <.td(
+            <.a(Attr("data-toggle") := "modal", Attr("data-target") := "#moduleEdit", ^.`class` := "icon-action",
+              ^.onClick ==> backend.editModule(idx),
+              icon.edit
+            )
+          ),
+          <.td(
+            <.a(Attr("data-toggle") := "modal", Attr("data-target") := "#moduleRemove", ^.`class` := "icon-action",
+              ^.onClick ==> backend.removeModule(idx),
+              icon.remove
+            )
+          )
+        )
+
+      <.div(
+        <.p(
+          <.button(^.`type` := "button", ^.`class` := "btn btn-default customButton",
+            ^.onClick ==> backend.addModule,
+            Attr("data-toggle") := "modal", Attr("data-target") := "#moduleEdit",
+            "Add"
+          )
+        ),
+        <.table(^.`class` := "table",
+          <.thead(
+            <.tr(
+              <.th("Organization"),
+              <.th("Name"),
+              <.th("Version"),
+              <.th(""),
+              <.th("")
+            )
+          ),
+          <.tbody(
+            deps.zipWithIndex.map((depItem _).tupled)
+          )
+        ),
+        moduleEditModal((deps.lift(editModuleIdx).fold(Module("", "", ""))(_.module), editModuleIdx, backend))
+      )
+    }
+    .build
+
+  val modules = dependenciesTable("Dependencies")
+
+  val repositories = ReactComponentB[Seq[Remote]]("Repositories")
+    .render{ repos =>
+      def repoItem(repo: Remote) =
+        <.tr(
+          <.td(
+            <.a(^.href := repo.base,
+              repo.base
+            )
+          )
+        )
+
+      val sortedRepos = repos
+        .sortBy(repo => repo.base)
+
+      <.table(^.`class` := "table",
+        <.thead(
+          <.tr(
+            <.th("Base URL")
+          )
+        ),
+        <.tbody(
+          sortedRepos.map(repoItem)
+        )
+      )
+    }
+    .build
+
+  val options = ReactComponentB[(ResolutionOptions, Backend)]("ResolutionOptions")
+    .render{ P =>
+      val (options, backend) = P
+
+      <.div(
+        <.div(^.`class` := "checkbox",
+          <.label(
+            <.input(^.`type` := "checkbox",
+              ^.onChange ==> backend.options.toggleOptional,
+              if (options.followOptional) Seq(^.checked := "checked") else Seq(),
+              "Follow optional dependencies"
+            )
+          )
+        ),
+        <.div(^.`class` := "checkbox",
+          <.label(
+            <.input(^.`type` := "checkbox",
+              ^.onChange ==> backend.options.toggleTest,
+              if (options.keepTest) Seq(^.checked := "checked") else Seq(),
+              "Keep test dependencies"
+            )
+          )
+        )
+      )
+    }
+    .build
+
+  val resolution = ReactComponentB[Option[Resolution]]("Resolution")
+    .render(resOpt =>
+      resOpt match {
+        case Some(res) =>
+          <.div(
+            <.div(^.`class` := "page-header",
+              <.h1("Resolution")
+            ),
+            resultDependencies(res)
+          )
+
+        case None =>
+          <.div()
+      }
+    )
+    .build
+
+  val initialState = State(Nil, Seq(coursier.repository.mavenCentral), ResolutionOptions(), None, -1, resolving = false, reverseTree = false, log = Nil)
+
+  val app = ReactComponentB[Unit]("Coursier")
+    .initialState(initialState)
+    .backend(new Backend(_))
+    .render((_,S,B) =>
+      <.div(
+        <.div(^.role := "tabpanel",
+          <.ul(^.`class` := "nav nav-tabs", ^.role := "tablist",
+            <.li(^.role := "presentation", ^.`class` := "active",
+              <.a(^.href := "#dependencies", ^.aria.controls := "dependencies", ^.role := "tab", Attr("data-toggle") := "tab",
+                s"Dependencies (${S.modules.length})"
+              )
+            ),
+            <.li(^.role := "presentation",
+              <.a(^.href := "#repositories", ^.aria.controls := "repositories", ^.role := "tab", Attr("data-toggle") := "tab",
+                s"Repositories (${S.repositories.length})"
+              )
+            ),
+            <.li(^.role := "presentation",
+              <.a(^.href := "#options", ^.aria.controls := "options", ^.role := "tab", Attr("data-toggle") := "tab",
+                "Options"
+              )
+            )
+          ),
+          <.div(^.`class` := "tab-content",
+            <.div(^.role := "tabpanel", ^.`class` := "tab-pane active", ^.id := "dependencies",
+              modules((S.modules, S.editModuleIdx, B))
+            ),
+            <.div(^.role := "tabpanel", ^.`class` := "tab-pane", ^.id := "repositories",
+              repositories(S.repositories)
+            ),
+            <.div(^.role := "tabpanel", ^.`class` := "tab-pane", ^.id := "options",
+              options((S.options, B))
+            )
+          )
+        ),
+
+        <.div(<.form(^.onSubmit ==> B.handleResolve,
+          <.button(^.`type` := "submit", ^.id := "resolveButton", ^.`class` := "btn btn-lg btn-primary",
+            if (S.resolving) ^.disabled := "true" else Attr("active") := "true",
+            if (S.resolving) "Resolving..." else "Resolve"
+          )
+        )),
+
+
+        <.div(^.role := "tabpanel", ^.id := "results",
+          <.ul(^.`class` := "nav nav-tabs", ^.role := "tablist", ^.id := "resTabs",
+            <.li(^.role := "presentation", ^.id := "resResTab",
+              <.a(^.href := "#resolution", ^.aria.controls := "resolution", ^.role := "tab", Attr("data-toggle") := "tab",
+                "Resolution"
+              )
+            ),
+            <.li(^.role := "presentation", ^.id := "resLogTab",
+              <.a(^.href := "#log", ^.aria.controls := "log", ^.role := "tab", Attr("data-toggle") := "tab",
+                "Log"
+              )
+            ),
+            <.li(^.role := "presentation",
+              <.a(^.href := "#depgraph", ^.aria.controls := "depgraph", ^.role := "tab", Attr("data-toggle") := "tab",
+                "Graph"
+              )
+            ),
+            <.li(^.role := "presentation",
+              <.a(^.href := "#deptreepanel", ^.aria.controls := "deptreepanel", ^.role := "tab", Attr("data-toggle") := "tab",
+                "Tree"
+              )
+            )
+          ),
+          <.div(^.`class` := "tab-content",
+            <.div(^.role := "tabpanel", ^.`class` := "tab-pane", ^.id := "resolution",
+              resolution(S.resolutionOpt)
+            ),
+            <.div(^.role := "tabpanel", ^.`class` := "tab-pane", ^.id := "log",
+              <.button(^.`type` := "button", ^.`class` := "btn btn-default",
+                ^.onClick ==> B.clearLog,
+                "Clear"
+              ),
+              <.div(^.`class` := "well",
+                <.ul(^.`class` := "log",
+                  S.log.map(e => <.li(e))
+                )
+              )
+            ),
+            <.div(^.role := "tabpanel", ^.`class` := "tab-pane", ^.id := "depgraph",
+              <.button(^.`type` := "button", ^.`class` := "btn btn-default",
+                ^.onClick ==> B.updateDepGraphBtn(S.resolutionOpt.getOrElse(Resolution.empty)),
+                "Redraw"
+              ),
+              <.div(^.id := "depgraphcanvas")
+            ),
+            <.div(^.role := "tabpanel", ^.`class` := "tab-pane", ^.id := "deptreepanel",
+              <.div(^.`class` := "checkbox",
+                <.label(
+                  <.input(^.`type` := "checkbox",
+                    ^.onChange ==> B.toggleReverseTree,
+                    if (S.reverseTree) Seq(^.checked := "checked") else Seq(),
+                    "Reverse"
+                  )
+                )
+              ),
+              <.div(^.id := "deptree")
+            )
+          )
+        )
+      )
+    )
+    .buildU
+
+}
diff --git a/web/src/main/scala/coursier/web/Main.scala b/web/src/main/scala/coursier/web/Main.scala
new file mode 100644
index 000000000..f5e9e0831
--- /dev/null
+++ b/web/src/main/scala/coursier/web/Main.scala
@@ -0,0 +1,13 @@
+package coursier.web
+
+import japgolly.scalajs.react.React
+import scala.scalajs.js.annotation.JSExport
+import org.scalajs.dom.document
+
+@JSExport
+object Main {
+  @JSExport
+  def main(): Unit = {
+    React.render(App.app("Coursier"), document.getElementById("demoContent"))
+  }
+}