diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/NOTICE b/NOTICE
new file mode 100644
index 0000000..39edd96
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,8 @@
+Apache Sling JavaScript (Rhino) Scripting Support
+Copyright 2008 The Apache Software Foundation
+
+Apache Sling is based on source code originally developed 
+by Day Software (http://www.day.com/).
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
diff --git a/README.txt b/README.txt
new file mode 100644
index 0000000..1615682
--- /dev/null
+++ b/README.txt
@@ -0,0 +1,37 @@
+Apache Sling JavaScript (Rhino) Scripting Support
+
+Support for JavaScript scripting.
+
+Disclaimer
+==========
+Apache Sling is an effort undergoing incubation at The Apache Software Foundation (ASF),
+sponsored by the Apache Jackrabbit PMC. Incubation is required of all newly accepted
+projects until a further review indicates that the infrastructure, communications,
+and decision making process have stabilized in a manner consistent with other
+successful ASF projects. While incubation status is not necessarily a reflection of
+the completeness or stability of the code, it does indicate that the project has yet
+to be fully endorsed by the ASF.
+
+Getting Started
+===============
+
+This component uses a Maven 2 (http://maven.apache.org/) build
+environment. It requires a Java 5 JDK (or higher) and Maven (http://maven.apache.org/)
+2.0.7 or later. We recommend to use the latest Maven version.
+
+If you have Maven 2 installed, you can compile and
+package the jar using the following command:
+
+    mvn package
+
+See the Maven 2 documentation for other build features.
+
+The latest source code for this component is available in the
+Subversion (http://subversion.tigris.org/) source repository of
+the Apache Software Foundation. If you have Subversion installed,
+you can checkout the latest source using the following command:
+
+    svn checkout http://svn.apache.org/repos/asf/incubator/sling/trunk/scripting/javascript
+
+See the Subversion documentation for other source control features.
+
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..47ea509
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,143 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you 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.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.apache.sling</groupId>
+        <artifactId>sling</artifactId>
+        <version>3-incubator</version>
+        <relativePath>../../parent/pom.xml</relativePath>
+    </parent>
+
+    <artifactId>org.apache.sling.scripting.javascript</artifactId>
+    <version>2.0.2-incubator</version>
+    <packaging>bundle</packaging>
+
+    <name>Sling - Scripting - JavaScript Support</name>
+    <description>Support for JavaScript scripting</description>
+
+    <scm>
+        <connection>scm:svn:http://svn.apache.org/repos/asf/incubator/sling/tags/org.apache.sling.scripting.javascript-2.0.2-incubator</connection>
+        <developerConnection>scm:svn:https://svn.apache.org/repos/asf/incubator/sling/tags/org.apache.sling.scripting.javascript-2.0.2-incubator</developerConnection>
+        <url>http://svn.apache.org/viewvc/incubator/sling/tags/org.apache.sling.scripting.javascript-2.0.2-incubator</url>
+    </scm>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-scr-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-bundle-plugin</artifactId>
+                <extensions>true</extensions>
+                <configuration>
+                    <instructions>
+                        <Private-Package>
+                            org.apache.sling.scripting.javascript.*,
+                            org.mozilla.classfile,
+                            !org.mozilla.javascript.xml.impl.xmlbeans,
+                            org.mozilla.javascript.*
+                        </Private-Package>
+                        <DynamicImport-Package>*</DynamicImport-Package>
+                        <ScriptEngine-Name>${pom.name}</ScriptEngine-Name>
+                        <ScriptEngine-Version>${pom.version}</ScriptEngine-Version>
+                    </instructions>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+    <reporting>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+                <configuration>
+                  <!-- No javadocs -->
+                    <excludePackageNames>
+                        org.apache.sling.scripting.javascript
+                    </excludePackageNames>
+                </configuration>
+            </plugin>
+        </plugins>
+    </reporting>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.sling</groupId>
+            <artifactId>org.apache.sling.api</artifactId>
+            <version>2.0.2-incubator</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.sling</groupId>
+            <artifactId>org.apache.sling.scripting.api</artifactId>
+            <version>2.0.2-incubator</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.sling</groupId>
+            <artifactId>org.apache.sling.jcr.resource</artifactId>
+            <version>2.0.2-incubator</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.sling</groupId>
+            <artifactId>org.apache.sling.commons.testing</artifactId>
+            <version>2.0.2-incubator</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.jackrabbit</groupId>
+            <artifactId>jackrabbit-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.sling</groupId>
+            <artifactId>org.apache.sling.commons.json</artifactId>
+            <version>2.0.2-incubator</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>servlet-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>javax.jcr</groupId>
+            <artifactId>jcr</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>rhino</groupId>
+            <artifactId>js</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </dependency>
+        <!-- Testing -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/src/main/java/org/apache/sling/scripting/javascript/RhinoJavaScriptEngine.java b/src/main/java/org/apache/sling/scripting/javascript/RhinoJavaScriptEngine.java
new file mode 100644
index 0000000..523a50f
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/RhinoJavaScriptEngine.java
@@ -0,0 +1,123 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+package org.apache.sling.scripting.javascript;
+
+import java.io.Reader;
+import java.util.Map.Entry;
+
+import javax.script.Bindings;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngineFactory;
+import javax.script.ScriptException;
+
+import org.apache.sling.api.scripting.SlingBindings;
+import org.apache.sling.api.scripting.SlingScriptHelper;
+import org.apache.sling.scripting.api.AbstractSlingScriptEngine;
+import org.apache.sling.scripting.javascript.helper.SlingWrapFactory;
+import org.apache.sling.scripting.javascript.io.EspReader;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.JavaScriptException;
+import org.mozilla.javascript.NativeObject;
+import org.mozilla.javascript.ScriptRuntime;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptableObject;
+import org.slf4j.Logger;
+
+/**
+ * A ScriptEngine that uses the Rhino interpreter to process Sling requests with
+ * server-side javascript.
+ */
+public class RhinoJavaScriptEngine extends AbstractSlingScriptEngine {
+
+    private Scriptable rootScope;
+
+    public RhinoJavaScriptEngine(ScriptEngineFactory factory, Scriptable rootScope) {
+        super(factory);
+        this.rootScope = rootScope;
+    }
+
+    public Object eval(Reader scriptReader, ScriptContext scriptContext)
+            throws ScriptException {
+        Bindings bindings = scriptContext.getBindings(ScriptContext.ENGINE_SCOPE);
+        String scriptName = "NO_SCRIPT_NAME";
+        {
+            SlingScriptHelper helper = (SlingScriptHelper) bindings.get(SlingBindings.SLING);
+            if(helper != null) {
+                scriptName = helper.getScript().getScriptResource().getPath();
+            }
+        }
+
+        // wrap the reader in an EspReader for ESP scripts
+        if (scriptName.endsWith(RhinoJavaScriptEngineFactory.ESP_SCRIPT_EXTENSION)) {
+            scriptReader = new EspReader(scriptReader);
+        }
+
+        // create a rhino Context and execute the script
+        try {
+            
+            final Context rhinoContext = Context.enter();
+            final ScriptableObject scope = new NativeObject();
+
+            // Set the global scope to be our prototype
+            scope.setPrototype(rootScope);
+
+            // We want "scope" to be a new top-level scope, so set its parent
+            // scope to null. This means that any variables created by assignments
+            // will be properties of "scope".
+            scope.setParentScope(null);
+
+            // setup the context for use
+            rhinoContext.setWrapFactory(SlingWrapFactory.INSTANCE);
+
+            // add initial properties to the scope
+            for (Object entryObject : bindings.entrySet()) {
+                Entry<?, ?> entry = (Entry<?, ?>) entryObject;
+                Object wrapped = ScriptRuntime.toObject(scope, entry.getValue());
+                ScriptableObject.putProperty(scope, (String) entry.getKey(),
+                    wrapped);
+            }
+
+            final int lineNumber = 1;
+            final Object securityDomain = null;
+
+            return rhinoContext.evaluateReader(scope, scriptReader, scriptName,
+                lineNumber, securityDomain);
+
+        } catch (JavaScriptException t) {
+            
+            final ScriptException se = new ScriptException(t.details(),
+                t.sourceName(), t.lineNumber());
+
+            ((Logger) bindings.get(SlingBindings.LOG)).error(t.getScriptStackTrace());
+            se.setStackTrace(t.getStackTrace());
+            throw se;
+            
+        } catch (Throwable t) {
+            
+            final ScriptException se = new ScriptException("Failure running script " + scriptName
+                + ": " + t.getMessage());
+            se.initCause(t);
+            throw se;
+            
+        } finally {
+            
+            Context.exit();
+            
+        }
+    }
+
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/RhinoJavaScriptEngineFactory.java b/src/main/java/org/apache/sling/scripting/javascript/RhinoJavaScriptEngineFactory.java
new file mode 100644
index 0000000..7740ad3
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/RhinoJavaScriptEngineFactory.java
@@ -0,0 +1,136 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.javascript;
+
+import javax.script.ScriptEngine;
+
+import org.apache.sling.scripting.api.AbstractScriptEngineFactory;
+import org.apache.sling.scripting.javascript.helper.SlingContextFactory;
+import org.apache.sling.scripting.javascript.helper.SlingWrapFactory;
+import org.apache.sling.scripting.javascript.helper.SlingWrapper;
+import org.apache.sling.scripting.javascript.wrapper.ScriptableCalendar;
+import org.apache.sling.scripting.javascript.wrapper.ScriptableItemMap;
+import org.apache.sling.scripting.javascript.wrapper.ScriptableNode;
+import org.apache.sling.scripting.javascript.wrapper.ScriptablePrintWriter;
+import org.apache.sling.scripting.javascript.wrapper.ScriptableProperty;
+import org.apache.sling.scripting.javascript.wrapper.ScriptableResource;
+import org.apache.sling.scripting.javascript.wrapper.ScriptableVersion;
+import org.apache.sling.scripting.javascript.wrapper.ScriptableVersionHistory;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptableObject;
+import org.mozilla.javascript.tools.debugger.ScopeProvider;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The <code>RhinoJavaScriptEngineFactory</code> TODO
+ */
+public class RhinoJavaScriptEngineFactory extends AbstractScriptEngineFactory
+        implements ScopeProvider {
+
+    public final static String ECMA_SCRIPT_EXTENSION = "ecma";
+
+    public final static String ESP_SCRIPT_EXTENSION = "esp";
+
+    private static final Class<?>[] HOSTOBJECT_CLASSES = {
+        ScriptableResource.class, 
+        ScriptableNode.class,
+        ScriptableProperty.class, 
+        ScriptableItemMap.class,
+        ScriptablePrintWriter.class,
+        ScriptableVersionHistory.class,
+        ScriptableVersion.class,
+        ScriptableCalendar.class
+    };
+
+    /** default log */
+    private final Logger log = LoggerFactory.getLogger(getClass());
+    
+    private final String languageVersion;
+
+    private Scriptable rootScope;
+
+    public RhinoJavaScriptEngineFactory() {
+
+        // initialize the Rhino Context Factory
+        SlingContextFactory.setup(this);
+
+        Context cx = Context.enter();
+        setEngineName(getEngineName() + " (" + cx.getImplementationVersion()
+            + ")");
+        languageVersion = String.valueOf(cx.getLanguageVersion());
+        Context.exit();
+
+        setExtensions(ECMA_SCRIPT_EXTENSION, ESP_SCRIPT_EXTENSION);
+        setMimeTypes("text/javascript", "application/ecmascript",
+            "application/javascript");
+        setNames("javascript", ECMA_SCRIPT_EXTENSION, ESP_SCRIPT_EXTENSION);
+    }
+
+    public ScriptEngine getScriptEngine() {
+        return new RhinoJavaScriptEngine(this, getRootScope());
+    }
+
+    public String getLanguageName() {
+        return "ECMAScript";
+    }
+
+    public String getLanguageVersion() {
+        return languageVersion;
+    }
+
+    public Scriptable getScope() {
+        return getRootScope();
+    }
+
+    private Scriptable getRootScope() {
+        if (rootScope == null) {
+            final Context rhinoContext = Context.enter();
+            rootScope = rhinoContext.initStandardObjects();
+
+            for (Class<?> clazz : HOSTOBJECT_CLASSES) {
+                try {
+
+                    // register the host object
+                    ScriptableObject.defineClass(rootScope, clazz);
+                    final ScriptableObject host = (ScriptableObject) clazz.newInstance();
+
+                    if (SlingWrapper.class.isAssignableFrom(clazz)) {
+                        // SlingWrappers can map to several classes if needed
+                        final SlingWrapper hostWrapper = (SlingWrapper) host;
+                        for (Class<?> c : hostWrapper.getWrappedClasses()) {
+                            SlingWrapFactory.INSTANCE.registerWrapper(c,
+                                hostWrapper.getClassName());
+                        }
+                    } else {
+                        // but other ScriptableObjects need to be registered as
+                        // well
+                        SlingWrapFactory.INSTANCE.registerWrapper(
+                            host.getClass(), host.getClassName());
+                    }
+                } catch (Throwable t) {
+                    log.warn("getRootScope: Cannot prepare host object " + clazz, t);
+                }
+            }
+        }
+
+        return rootScope;
+    }
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/helper/SlingContext.java b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingContext.java
new file mode 100644
index 0000000..1272894
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingContext.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.javascript.helper;
+
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.ScriptableObject;
+
+/**
+ * The <code>SlingContext</code> extends Context to overwrite the
+ * {@link #initStandardObjects(ScriptableObject, boolean)} method to add more
+ * standard objects.
+ */
+public class SlingContext extends Context {
+
+    @Override
+    public ScriptableObject initStandardObjects(ScriptableObject scope,
+            boolean sealed) {
+        ScriptableObject rootScope = super.initStandardObjects(scope, sealed);
+
+        // add Sling global objects
+        SlingGlobal.init(rootScope, sealed);
+
+        return rootScope;
+    }
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/helper/SlingContextFactory.java b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingContextFactory.java
new file mode 100644
index 0000000..46b4b05
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingContextFactory.java
@@ -0,0 +1,95 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.javascript.helper;
+
+import java.io.File;
+
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.ContextFactory;
+import org.mozilla.javascript.tools.debugger.ScopeProvider;
+
+/**
+ * The <code>SlingContextFactory</code> extends the standard Rhino
+ * ContextFactory to provide customized settings, such as having the dynamic
+ * scope feature enabled by default. Other functionality, which may be added
+ * would be something like a configurable maximum script runtime value.
+ */
+public class SlingContextFactory extends ContextFactory {
+
+    private SlingRhinoDebugger debugger;
+    private ScopeProvider scopeProvider;
+    private boolean debuggerActive;
+    
+    // conditionally setup the global ContextFactory to be ours. If
+    // a global context factory has already been set, we have lost
+    // and cannot set this one.
+    public static void setup(ScopeProvider sp) {
+        // TODO what do we do in the other case? debugger won't work
+        if (!hasExplicitGlobal()) {
+            initGlobal(new SlingContextFactory(sp));
+        }
+    }
+    
+    // private as instances of this class are only used by setup()
+    private SlingContextFactory(ScopeProvider sp) 
+    {
+        scopeProvider = sp;
+        
+        // TODO make this configurable via OSGi
+        File f = new File("/tmp/sling.debug");
+        debuggerActive = f.exists();
+    }
+    
+    @Override
+    protected Context makeContext() {
+        return new SlingContext();
+    }
+    
+    @Override
+    protected boolean hasFeature(Context cx, int featureIndex) {
+        if (featureIndex == Context.FEATURE_DYNAMIC_SCOPE) {
+            return true;
+        }
+
+        return super.hasFeature(cx, featureIndex);
+    }
+    
+    @Override
+    protected void onContextCreated(Context cx) {
+        super.onContextCreated(cx);
+        initDebugger(cx);
+    }
+
+    private void initDebugger(Context cx) {
+        if(!debuggerActive) {
+            return;
+        }
+        try {
+            if (debugger == null) {
+                debugger = new SlingRhinoDebugger(getClass().getSimpleName());
+                debugger.setScopeProvider(scopeProvider);
+                debugger.attachTo(this);
+            }
+        } catch (Exception e) {
+            // TODO log
+            System.err.println("SlingContextFactory.initDebugger(): " + e);
+        }
+    }
+    
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/helper/SlingGlobal.java b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingGlobal.java
new file mode 100644
index 0000000..e15d246
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingGlobal.java
@@ -0,0 +1,243 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.javascript.helper;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.io.Serializable;
+
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.apache.sling.api.resource.ResourceUtil;
+import org.apache.sling.api.scripting.SlingBindings;
+import org.apache.sling.api.scripting.SlingScriptHelper;
+import org.apache.sling.scripting.javascript.RhinoJavaScriptEngineFactory;
+import org.apache.sling.scripting.javascript.io.EspReader;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.IdFunctionCall;
+import org.mozilla.javascript.IdFunctionObject;
+import org.mozilla.javascript.Kit;
+import org.mozilla.javascript.ScriptRuntime;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptableObject;
+import org.mozilla.javascript.Wrapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The <code>SlingGlobal</code> class provides two interesting new global
+ * functions which are not part of the ECMAScript standard but which are
+ * available in the Rhino Shell and which may be of use by JavaScripts:
+ * <p>
+ * <dl>
+ * <dt><code>print(args, ...)</code></dt>
+ * <dd>Prints the arguments <code>args</code> in a single message to the
+ * scripts logger available as the global <em>log</em> variable.</dd>
+ * <dt><code>load(args, ...)</code></dt>
+ * <dd>Loads the scripts named as parameters into the current scope one, after
+ * the other. Usually the script files are read as plain JavaScript files. If
+ * the file extension happens to be <em>.esp</em> to indicate an ECMAScript
+ * Server Page, the file is read through an
+ * {@link org.apache.sling.scripting.javascript.io.EspReader}. Failure to read
+ * one of the files throws an error.</dd>
+ * </dl>
+ */
+public class SlingGlobal implements Serializable, IdFunctionCall {
+    static final long serialVersionUID = 6080442165748707530L;
+
+    private static final Object FTAG = new Object();
+
+    private static final int Id_load = 1;
+
+    private static final int Id_print = 2;
+
+    private static final int LAST_SCOPE_FUNCTION_ID = 2;
+
+    /** default log */
+    private final Logger defaultLog = LoggerFactory.getLogger(getClass());
+
+    public static void init(Scriptable scope, boolean sealed) {
+        SlingGlobal obj = new SlingGlobal();
+
+        for (int id = 1; id <= LAST_SCOPE_FUNCTION_ID; ++id) {
+            String name;
+            int arity = 1;
+            switch (id) {
+                case Id_load:
+                    name = "load";
+                    break;
+                case Id_print:
+                    name = "print";
+                    break;
+                default:
+                    throw Kit.codeBug();
+            }
+            IdFunctionObject f = new IdFunctionObject(obj, FTAG, id, name,
+                arity, scope);
+            if (sealed) {
+                f.sealObject();
+            }
+            f.exportAsScopeProperty();
+        }
+
+    }
+
+    public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope,
+            Scriptable thisObj, Object[] args) {
+        if (f.hasTag(FTAG)) {
+            int methodId = f.methodId();
+            switch (methodId) {
+                case Id_load: {
+                    load(cx, thisObj, args);
+                    return Context.getUndefinedValue();
+                }
+
+                case Id_print: {
+                    print(cx, thisObj, args);
+                    return Context.getUndefinedValue();
+                }
+            }
+        }
+        throw f.unknown();
+    }
+
+    private void print(Context cx, Scriptable thisObj, Object[] args) {
+        StringBuffer message = new StringBuffer();
+        for (int i = 0; i < args.length; i++) {
+            if (i > 0) {
+                message.append(" ");
+            }
+            // Convert the arbitrary JavaScript value into a string form.
+            String s = ScriptRuntime.toString(args[i]);
+
+            message.append(s);
+        }
+
+        getLogger(cx, thisObj).info(message.toString());
+    }
+
+    private void load(Context cx, Scriptable thisObj, Object[] args) {
+
+        SlingScriptHelper sling = getProperty(cx, thisObj, SlingBindings.SLING,
+            SlingScriptHelper.class);
+        if (sling == null) {
+            throw new NullPointerException(SlingBindings.SLING);
+        }
+
+        Scriptable globalScope = ScriptableObject.getTopLevelScope(thisObj);
+
+        Resource scriptResource = sling.getScript().getScriptResource();
+        ResourceResolver resolver = scriptResource.getResourceResolver();
+
+        // the path of the current script to resolve realtive paths
+        String currentScript = sling.getScript().getScriptResource().getPath();
+        String scriptParent = ResourceUtil.getParent(currentScript);
+
+        for (Object arg : args) {
+            String scriptName = ScriptRuntime.toString(arg);
+
+            Resource loadScript = null;
+            if (!scriptName.startsWith("/")) {
+                String absScriptName = scriptParent + "/" + scriptName;
+                loadScript = resolver.resolve(absScriptName);
+            }
+
+            // not resolved relative to the current script
+            if (loadScript == null) {
+                loadScript = resolver.resolve(scriptName);
+            }
+
+            if (loadScript == null) {
+                throw Context.reportRuntimeError("Script file " + scriptName
+                    + " not found");
+            }
+
+            InputStream scriptStream = loadScript.adaptTo(InputStream.class);
+            if (scriptStream == null) {
+                throw Context.reportRuntimeError("Script file " + scriptName
+                    + " cannot be read from");
+            }
+
+            try {
+                // reader for the stream
+                Reader scriptReader = new InputStreamReader(scriptStream);
+
+                // check whether we have to wrap the basic reader
+                if (scriptName.endsWith(RhinoJavaScriptEngineFactory.ESP_SCRIPT_EXTENSION)) {
+                    scriptReader = new EspReader(scriptReader);
+                }
+
+                // read the suff buffered for better performance
+                scriptReader = new BufferedReader(scriptReader);
+
+                // now, let's go
+                cx.evaluateReader(globalScope, scriptReader, scriptName, 1,
+                    null);
+
+            } catch (IOException ioe) {
+
+                throw Context.reportRuntimeError("Failure reading file "
+                    + scriptName + ": " + ioe);
+
+            } finally {
+                // ensure the script input stream is closed
+                try {
+                    scriptStream.close();
+                } catch (IOException ignore) {
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns the script logger or the logger of this class as a fallback
+     * default if the global log variable is not accessible.
+     */
+    private Logger getLogger(Context cx, Scriptable scope) {
+        Logger log = getProperty(cx, scope, SlingBindings.LOG, Logger.class);
+        if (log == null) {
+            log = this.defaultLog;
+        }
+        return log;
+    }
+
+    /**
+     * Returns the named toplevel property converted to the requested
+     * <code>type</code> or <code>null</code> if no such property exists or
+     * the property is of the wrong type.
+     */
+    @SuppressWarnings("unchecked")
+    private <Type> Type getProperty(Context cx, Scriptable scope, String name,
+            Class<Type> type) {
+        Object prop = ScriptRuntime.name(cx, scope, name);
+
+        if (prop instanceof Wrapper) {
+            prop = ((Wrapper) prop).unwrap();
+        }
+
+        if (type.isInstance(prop)) {
+            return (Type) prop; // unchecked case
+        }
+
+        return null;
+    }
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/helper/SlingRhinoDebugger.java b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingRhinoDebugger.java
new file mode 100644
index 0000000..d24e631
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingRhinoDebugger.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+package org.apache.sling.scripting.javascript.helper;
+
+import org.mozilla.javascript.tools.debugger.Dim;
+import org.mozilla.javascript.tools.debugger.SwingGui;
+
+class SlingRhinoDebugger extends Dim {
+    SlingRhinoDebugger(String windowTitle) {
+        final SwingGui gui = new SwingGui(this, windowTitle);
+        gui.pack();
+        gui.setVisible(true);
+    }
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/helper/SlingWrapFactory.java b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingWrapFactory.java
new file mode 100644
index 0000000..c23c45d
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingWrapFactory.java
@@ -0,0 +1,119 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.javascript.helper;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.WrapFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SlingWrapFactory extends WrapFactory {
+
+    public static final SlingWrapFactory INSTANCE = new SlingWrapFactory();
+    
+    /** List of classes that must not be wrapped (added for SLING-382) */
+    private static final Class<?>[] EXCLUDED_CLASSES = {};
+
+    /** default log */
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    private Map<Class<?>, String> wrappers = new HashMap<Class<?>, String>();
+
+    /**
+     * @param cx the current Context for this thread
+     * @param scope the scope of the executing script
+     * @param javaObject the object to be wrapped
+     * @param staticType type hint. If security restrictions prevent to wrap
+     *            object based on its class, staticType will be used instead.
+     * @return the wrapped value which shall not be null
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public Scriptable wrapAsJavaObject(Context cx, Scriptable scope,
+            Object javaObject, Class staticType) {
+
+        Scriptable result = null;
+        try {
+            String hostObjectName = getHostObjectName(staticType);
+
+            if (hostObjectName == null) {
+                hostObjectName = getHostObjectName(javaObject.getClass());
+            }
+
+            if (hostObjectName != null) {
+                result = cx.newObject(scope, hostObjectName,
+                    new Object[] { javaObject });
+            }
+        } catch (Exception e) {
+            log.warn("Cannot Wrap " + javaObject, e);
+        }
+
+        if(result==null) {
+            result = super.wrapAsJavaObject(cx, scope, javaObject, staticType);
+        }
+
+        return result;
+    }
+
+    private String getHostObjectName(Class<?> javaClass) {
+        if(javaClass==null || isExcluded(javaClass)) {
+            return null;
+        }
+        String hostObjectName = wrappers.get(javaClass);
+        if (hostObjectName == null) {
+            // before SLING-383 the superclass was tested first,
+            // but for Version and VersionHistory this would get 
+            // a Node wrapper, that's not what we want
+            final Class<?>[] javaInterfaces = javaClass.getInterfaces();
+            for (int i = 0; i < javaInterfaces.length && hostObjectName == null; i++) {
+                hostObjectName = getHostObjectName(javaInterfaces[i]);
+            }
+
+            if (hostObjectName == null) {
+                hostObjectName = getHostObjectName(javaClass.getSuperclass());
+            }
+        }
+
+        return hostObjectName;
+    }
+
+    /*
+     * Is this class in the excluded class  list?
+     */
+    private boolean isExcluded(Class<?> javaClass) {
+        for (Class<?> type : EXCLUDED_CLASSES) {
+            if (type.isAssignableFrom(javaClass)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void registerWrapper(Class<?> javaClass, String hostObjectName) {
+        wrappers.put(javaClass, hostObjectName);
+    }
+
+    public void unregisterWrapper(Class<?> javaClass) {
+        wrappers.remove(javaClass);
+    }
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/helper/SlingWrapper.java b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingWrapper.java
new file mode 100644
index 0000000..4c4edec
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/helper/SlingWrapper.java
@@ -0,0 +1,36 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.javascript.helper;
+
+import org.mozilla.javascript.Wrapper;
+
+/** Wrapper with an additional methods to indicate the wrapped classes */
+public interface SlingWrapper extends Wrapper {
+
+    /**
+     * The name of the JavaScript host object "class"
+     */
+    String getClassName();
+    
+    /**
+     * The list of Java classes wrapped by this wrapper
+     */
+    Class<?> [] getWrappedClasses();
+    
+}
\ No newline at end of file
diff --git a/src/main/java/org/apache/sling/scripting/javascript/io/EspReader.java b/src/main/java/org/apache/sling/scripting/javascript/io/EspReader.java
new file mode 100644
index 0000000..c8a57f7
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/io/EspReader.java
@@ -0,0 +1,802 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.javascript.io;
+
+import java.io.FilterReader;
+import java.io.IOException;
+import java.io.PushbackReader;
+import java.io.Reader;
+import java.util.Stack;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The <code>EspReader</code> is a <code>FilterReader</code> which takes
+ * JSP like input and produces plain ECMA script output. The filtering
+ * modifications done on the input comprise the following :
+ * <ul>
+ * <li>Template text (HTML) is wrapped by out.write(). At most one line of
+ * text is wrapped into a single write() call. Double quote characters in the
+ * template text (e.g. for HTML tag attribute values) are escaped.
+ * <li>ECMA code is written to the output as is.
+ * <li>ECMA slash star (/*) comments are also written as is.
+ * <li>ECMA slash slash (//) comments are written as is.
+ * <li>JSP style template comments (<%-- -->) are also removed from the
+ * stream. Lineendings (LFs and CRLFs) are written, though.
+ * <li>HTML comments (<!-- -->) are not treated specially. Rather they are
+ * handled as plain template text written to the output wrapped in
+ * out.write(). The consequence of this behavious is, that as in JSP ECMA
+ * expressions may be included within the comments.
+ * </ul>
+ * <p>
+ * The nice thing about this reader is, that the line numbers of the resulting
+ * stream match the line numbers of the matching contents of the input stream.
+ * Due to the insertion of write() calls, column numbers will not necessarily
+ * match, though. This is especially true if you mix ECMA code tags (<% %>)
+ * with template text on the same line.
+ * <p>
+ * For maximum performance it is advisable to not create the EspReader with a
+ * plain FileReader or InputStreamReader but rather with a BufferedReader based
+ * on one of the simpler Readers. The reasons for this is, that we call the base
+ * reader character by character. This in turn is not too performing if the base
+ * reader does not buffer its input.
+ */
+public class EspReader extends FilterReader {
+
+    /** default log */
+    private final Logger log = LoggerFactory.getLogger(EspReader.class);
+
+    /**
+     * Default parser state. This is the state the parser starts running in. In
+     * this state all text is treated as template text, which should be wrapped
+     * by out.write() line by line.
+     */
+    private static final byte PARSE_STATE_ESP = 1;
+
+    /**
+     * ECMA script reading state. When in this state everything upto to the next
+     * <code>%&gt;</code> is written to the output verbatim with three
+     * exceptions : ECMA slash star comments are handed over to handled by the
+     * {@link #PARSE_STATE_ECMA_COMMENT} state, quoted strings are handled in
+     * the {@link #PARSE_STATE_QUOTE} state and ECMA slash slash comments are
+     * handled in {@link #PARSE_STATE_ECMA_COMMENTL} state.
+     */
+    private static final byte PARSE_STATE_ECMA = 2;
+
+    /**
+     * ECMA script expression reading state. This state works exactly the same
+     * as the {@link #PARSE_STATE_ECMA} state with one exception: The whole
+     * code enclosed in the <code>&lt;%=</code> ... <code>%&gt;</code> tags
+     * is itself wrapped with a <code>out.write()</code> statement
+     * verbatim.
+     */
+    private static final byte PARSE_STATE_ECMA_EXPR = 3;
+
+    /**
+     * Compact ESP expression syntax similar to JSP Expression Language notation 
+     */
+    private static final byte PARSE_STATE_ECMA_EXPR_COMPACT = 4;
+
+    /**
+     * JSP comment reading state. When in this state everything upto the closing
+     * <code>--&gt;</code> tag is removed from the stream.
+     */
+    private static final byte PARSE_STATE_JSP_COMMENT = 5;
+
+    /**
+     * ECMA quoted string reading state. When in this state everything is
+     * written exactly as in the input stream upto the closing quote, which
+     * matches the opening quote.
+     */
+    private static final byte PARSE_STATE_QUOTE = 6;
+
+    /**
+     * Verbatim copy state. When in this state as many as verbatimChars
+     * characters are returned unchecked. As soon as this number of characters
+     * is returned, the last state is popped from the stack. This state is
+     * mainly used to (re-)inject static text into the output without further
+     * processing.
+     */
+    private static final byte PARSE_STATE_VERBATIM = 7;
+
+    /**
+     * ECMA Comment reading state. When in this state, an ECMA slash star
+     * comment is read (and completely returned).
+     */
+    private static final byte PARSE_STATE_ECMA_COMMENT = 8;
+
+    /**
+     * ECMA Comment reading state. When in this state, an ECMA slash slash
+     * comment is read (and completely returned).
+     */
+    private static final byte PARSE_STATE_ECMA_COMMENTL = 9;
+    
+    /**
+     * To work with lookahead and character insertion, we use a PushbackReader.
+     */
+    private PushbackReader input;
+
+    /**
+     * Current parse state. This field contains one of the
+     * <code>PARSE_STATE</code> constants.
+     */
+    private byte state;
+
+    /**
+     * Stack of states. Whenever we enter a new state, the old state is pushed
+     * onto the stack. When a state is left, the previous one is popped from the
+     * stack.
+     *
+     * @see #pushState(byte)
+     * @see #popState()
+     * @see #state
+     */
+    private Stack<Byte> stateStack;
+
+    /**
+     * This value is set to true, if the parser is expected to insert a
+     * out.write() call into the input stream when in state
+     * {@link #PARSE_STATE_ESP}. When this field is true, it is not
+     * necessairily the case, that we are at the start of a real text line.
+     */
+    private boolean lineStart;
+
+    /**
+     * If characters are put into the pushback Stream that should be given back
+     * verbatim, this value is set to the number of such consecutive characters.
+     */
+    private int verbatimChars;
+
+    /**
+     * During String matching this is the character used for string quoting.
+     */
+    private char quoteChar;
+
+    /**
+     * Set to true if an escape character (\) has been encountered within a
+     * quoted string.
+     */
+    private boolean escape;
+
+    /**
+     * Whether the definition of the out variable has already been written or not.
+     * The initial value is <code>true</code> indicating it has still to be
+     * defined.
+     *
+     * @see #startWrite(String)
+     */
+    private boolean outUndefined = true;
+    
+    /**
+     * Javascript statement that sets the "out" variable that's used
+     * to output data. Automatically inserted by the reader in code,
+     * where needed.
+     */
+    public static final String DEFAULT_OUT_INIT_STATEMENT = "out=response.writer;"; 
+    private String outInitStatement = DEFAULT_OUT_INIT_STATEMENT;
+
+    /**
+     * Create an EspReader on top of the given <code>baseReader</code>. The
+     * constructor wraps the input reader with a <code>PushbackReader</code>,
+     * so that input stream modifications may be handled transparently by our
+     * {@link #doRead()} method.
+     */
+    public EspReader(Reader baseReader) {
+        super(baseReader);
+        this.input = new PushbackReader(baseReader, 100);
+        this.stateStack = new Stack<Byte>();
+        this.lineStart = true;
+        this.verbatimChars = -1;
+        this.quoteChar = 0;
+        this.escape = false;
+
+        // Start in ESP (template text) state
+        pushState(PARSE_STATE_ESP);
+    }
+    
+    /** Set the code fragment used to initialize the "out" variable */
+    public void setOutInitStatement(String statement) {
+        outInitStatement = statement;
+    }
+
+    /**
+     * Check whether we may block at the next read() operation. We may be ready
+     * if and only if our input reader is ready. But this does not guarantee
+     * that we won't block, as due to filtering there may be more than one
+     * character needed from the input to return one.
+     *
+     * @return <code>true</code> if a character is available on the
+     *         <code>PushbackReader</code>.
+     * @throws IOException if the reader is not open
+     */
+    public boolean ready() throws IOException {
+        ensureOpen();
+        return input.ready();
+    }
+
+    /**
+     * Return the next filtered character. This need not be the next character
+     * of the input stream. It may be a character from the input reader, after
+     * having skipped filtered characters or it may be a character injected due
+     * to translation of template text to ECMA code.
+     *
+     * @return the next character after filtering or -1 at the end of the input
+     *         reader
+     * @throws IOException if the reader is not open
+     */
+    public int read() throws IOException {
+        ensureOpen();
+        return doRead();
+    }
+
+    /**
+     * Fill the given buffer with filtered or injected characters. This need not
+     * be the next characters of the input stream. It may be characters from the
+     * input reader, after having skipped filtered characters or it may be a
+     * characters injected due to translation of template text to ECMA code.
+     * This method is exactly the same as
+     * <code>read(cbuf, 0, cbuf.length)</code>.
+     *
+     * @param cbuf The character buffer to fill with (filtered) characters
+     * @return the number of characters filled in the buffer or -1 at the end of
+     *         the input reader.
+     * @throws IOException if the reader is not open
+     */
+    public int read(char[] cbuf) throws IOException {
+        return read(cbuf, 0, cbuf.length);
+    }
+
+    /**
+     * Fill the buffer from the offset with the number of characters given. This
+     * need not be the next characters of the input stream. It may be characters
+     * from the input reader, after having skipped filtered characters or it may
+     * be a characters injected due to translation of template text to ECMA
+     * code.
+     *
+     * @param cbuf The character buffer to fill with (filtered) characters
+     * @param off Offset from where to start in the buffer
+     * @param len The number of characters to fill into the buffer
+     * @return the number of characters filled in the buffer or -1 at the end of
+     *         the input reader.
+     * @throws IOException if the reader is not open
+     * @throws IndexOutOfBoundsException if len is negative, off is negative or
+     *             higher than the buffer length or off+len is negative or
+     *             beyond the buffer size.
+     */
+    public int read(char[] cbuf, int off, int len) throws java.io.IOException {
+        ensureOpen();
+
+        // Check lines (taken from InputStreamReader ;-)
+        if ((off < 0) || (off > cbuf.length) || (len < 0)
+            || ((off + len) > cbuf.length) || ((off + len) < 0)) {
+            throw new IndexOutOfBoundsException();
+        } else if (len == 0) {
+            return 0;
+        }
+
+        int i;
+        for (i = 0; i < len; i++, off++) {
+            int c = doRead();
+            if (c < 0) {
+                break;
+            }
+            cbuf[off] = (char) c;
+        }
+
+        // return EOF (-1) if none have been read, else return the number read
+        return (i == 0) ? -1 : i;
+    }
+
+    /**
+     * Skip the number of filtered characters. The skip method is the same as
+     * calling read() repeatedly for the given number of characters and throwing
+     * away the result. If the end of input reader is reached before having
+     * skipped the number of characters, the method returns the number
+     * characters skipped so far.
+     *
+     * @param n the number of (filtered) characters to skip
+     * @return the number of (filtered) characters actually skipped
+     * @throws IllegalArgumentException if n is negative
+     * @throws IOException if the reading the characters throws
+     */
+    public long skip(long n) throws IOException {
+        if (n < 0L) {
+            throw new IllegalArgumentException("skip value is negative");
+        }
+
+        long i = -1;
+        while (++i < n) {
+            if (doRead() < 0) {
+                break;
+            }
+        }
+        return i;
+    }
+
+    /**
+     * Close the EspReader.
+     */
+    public void close() throws java.io.IOException {
+        if (input != null) {
+            input.close();
+            input = null;
+        }
+
+        // I dont' know what happens ??
+        super.close();
+    }
+
+    /**
+     * Mark the present position in the stream. The <code>mark</code> for
+     * class <code>EspReader</code> always throws an throwable.
+     *
+     * @param readAheadLimit The number of characters to read ahead
+     * @exception IOException Always, since mark is not supported
+     */
+    public void mark(int readAheadLimit) throws IOException {
+        throw new IOException("mark() not supported");
+    }
+
+    /**
+     * Tell whether this stream supports the mark() operation, which it does
+     * not.
+     *
+     * @return false Always, since mark is not supported
+     */
+    public boolean markSupported() {
+        return false;
+    }
+
+    /**
+     * Reset the stream. The <code>reset</code> method of
+     * <code>EspReader</code> always throws an throwable.
+     *
+     * @exception IOException Always, since reset is not supported
+     */
+    public void reset() throws IOException {
+        throw new IOException("reset() not supported");
+    }
+
+    /**
+     * Internal routine doing all the footwork of reading one character at a
+     * time from the <code>PushbackReader</code> and acting according to the
+     * current state.
+     * <p>
+     * This filter is implemented using a finite state machine using the states
+     * defined above with the <code>PARSE_STATE</code> constants. Each state
+     * may do a look ahead in certain situations to decide on further steps.
+     * Characters looked ahead may or may not be inserted back into the input
+     * stream depending on the concrete state.
+     *
+     * @return the next character from the input stream according to the current
+     *         state or -1 to indicate end of file.
+     * @throws IOException if the input <code>PushbackReader</code> throws it
+     */
+    private int doRead() throws IOException {
+
+        // we return out of the loop, if we find a character passing the filter
+        for (;;) {
+
+            // Get a character from the input, which may well have been
+            // injected using the unread() method
+            int c = input.read();
+
+            // catch EOF
+            if (c < 0) {
+
+                // if a template text line is still incomplete, inject
+                // proper line ending and continue until this has been returned
+                if (!lineStart && state == PARSE_STATE_ESP) {
+                    doVerbatim("\");"); // line ending injection
+                    lineStart = true; // mark the line having ended
+                    continue; // let's start read the injection
+                }
+
+                return c; // return the marker, we're done
+            }
+
+            // Do the finite state machine
+            switch (state) {
+
+                // NOTE :
+                // - continue means ignore current character, read next
+                // - break means return current character
+
+                // Template text state - text is wrapped in out.write()
+                case PARSE_STATE_ESP:
+                    if (c == '$') { // might start EL-like ECMA expr
+                    	int c2 = input.read();
+                    	if (c2 == '{') {
+                            // ECMA expression ${ ... }
+                            pushState(PARSE_STATE_ECMA_EXPR_COMPACT);
+                            startWrite(null);
+                            if (!lineStart) {
+                                doVerbatim("\");");
+                            }
+                            continue;
+                    	}
+                    	 
+                    	input.unread(c2);
+
+                    } else  if (c == '<') { // might start ECMA code/expr, ESP comment or JSP comment
+                        int c2 = input.read();
+                        int c3 = input.read();
+
+                        if (c2 == '%') {
+                            // ECMA or JSP comment
+
+                            if (c3 == '=') {
+
+                                // ECMA expression <%= ... %>
+                                pushState(PARSE_STATE_ECMA_EXPR);
+                                startWrite(null);
+                                if (!lineStart) {
+                                    doVerbatim("\");");
+                                }
+                                continue;
+
+                            } else if (c3 == '-') {
+
+                                // (Possible) JSP Comment <%-- ... --%>
+                                int c4 = input.read();
+                                if (c4 == '-') {
+                                    pushState(PARSE_STATE_JSP_COMMENT);
+                                    continue;
+                                }
+                                input.unread(c4);
+
+                            }
+
+                            // We only get here if we are sure about ECMA
+
+                            // ECMA code <% ... %>
+                            input.unread(c3);
+                            pushState(PARSE_STATE_ECMA);
+                            if (!lineStart) {
+                                doVerbatim("\");");
+                            }
+                            continue;
+
+                        }
+
+                        // Nothing special, push back read ahead
+                        input.unread(c3);
+                        input.unread(c2);
+
+                        // End of template text line
+                    } else if (c == '\r' || c == '\n') {
+                        String lineEnd; // will be injected
+
+                        // Check for real CRLF
+                        if (c == '\r') {
+                            int c2 = input.read();
+                            if (c2 != '\n') {
+                                input.unread(c2);
+                                lineEnd = "\\r";
+                            } else {
+                                lineEnd = "\\r\\n";
+                            }
+                        } else {
+                            lineEnd = "\\n";
+                        }
+
+                        // Only write line ending if not empty
+                        if (!lineStart) {
+                            doVerbatim("\");\n");
+                            doVerbatim(lineEnd);
+                            lineStart = true;
+
+                        } else { // if (lineEnd.length() > 1) {
+                            // no matter what line ending we have, make it LF
+                            doVerbatim("\");\n");
+                            doVerbatim(lineEnd);
+                            startWrite("\"");
+                        }
+
+                        continue;
+
+                        // template text is wrapped with double quotes, which
+                        // when occurring in the text must be escaped.
+                        // We also escape the escape character..
+                    } else if (c == '"' || c == '\\') {
+
+                        doVerbatim(String.valueOf((char) c));
+                        c = '\\';
+
+                    }
+
+                    // If in template text at the beginning of a line
+                    if (lineStart) {
+                        lineStart = false;
+                        startWrite("\"" + (char) c);
+                        continue;
+                    }
+
+                    break;
+
+                // Reading ECMA code or and ECMA expression
+                case PARSE_STATE_ECMA_EXPR:
+                case PARSE_STATE_ECMA:
+
+                    if (c == '%') {
+
+                        // might return to PARSE_STATE_ESP
+                        int c2 = input.read();
+                        if (c2 == '>') {
+
+                            // An expression is wrapped in out.write()
+                            if (popState() == PARSE_STATE_ECMA_EXPR) {
+                                doVerbatim(");");
+                            }
+
+                            // next ESP needs out.write(
+                            lineStart = true;
+
+                            continue;
+
+                        }
+
+                        // false alert, push back
+                        input.unread(c2);
+
+                    } else if (c == '/') {
+
+                        // might be ECMA Comment
+                        int c2 = input.read();
+                        if (c2 == '/') {
+                            // single line comment
+                            pushState(PARSE_STATE_ECMA_COMMENTL);
+                        } else if (c2 == '*') {
+                            // multiline comment
+                            pushState(PARSE_STATE_ECMA_COMMENT);
+                        }
+
+                        // false alert, push back
+                        input.unread(c2);
+
+                    } else if (c == '\'' || c == '"') {
+
+                        // an ECMA string
+                        escape = false; // start unescaped
+                        quoteChar = (char) c; // to recognize the end
+                        pushState(PARSE_STATE_QUOTE);
+
+                    }
+                    break;
+
+                // reading compact (EL-like) ECMA Expression
+                case PARSE_STATE_ECMA_EXPR_COMPACT:
+                    if (c == '}') { //might be the end of a compact expression
+                        // An expression is wrapped in out.write()
+                        popState();
+                        doVerbatim(");");
+
+                        // next ESP needs out.write(
+                        lineStart = true;
+
+                        continue;
+
+                    }
+                    break;
+
+                // Reading a JSP comment, only returning line endings
+                case PARSE_STATE_JSP_COMMENT:
+
+                    // JSP comments end complexly with --%>
+                    if (c == '-') {
+                        int c2 = input.read();
+                        if (c2 == '-') {
+                            int c3 = input.read();
+                            if (c3 == '%') {
+                                int c4 = input.read();
+                                if (c4 == '>') {
+
+                                    // we really reached the end ...
+                                    popState();
+                                    continue;
+
+                                }
+                                input.unread(c4);
+                            }
+                            input.unread(c3);
+                        }
+                        input.unread(c2);
+
+                        // well, not definitely correct but reasonably accurate
+                        // ;-)
+                    } else if (c == '\r' || c == '\n') {
+
+                        // terminate an open template line
+                        if (!lineStart) {
+                            input.unread(c); // push back the character
+                            doVerbatim("\");"); // insert ");
+                            lineStart = true; // mark the line start
+                            continue; // Force read of the "
+                        }
+
+                        break;
+                    }
+
+                    // continue reading another character in the comment
+                    continue;
+
+                    // Read an ECMA string upto the ending quote character
+                case PARSE_STATE_QUOTE:
+
+                    // if unescaped quote character
+                    if (c == quoteChar && !escape) {
+                        popState();
+                    } else {
+                        // mark escape - only if not already escaped (bug 7079)
+                        escape = c == '\\' && !escape;
+                    }
+
+                    break;
+
+                // Return characters unfiltered
+                case PARSE_STATE_VERBATIM:
+
+                    // Go back to previous state if all characters read
+                    if (--verbatimChars < 0) {
+                        popState();
+                    }
+
+                    break;
+
+                // Return an ECMA multiline comment, ending with */
+                case PARSE_STATE_ECMA_COMMENT:
+
+                    // Might be the end of the comment
+                    if (c == '*') {
+                        int c2 = input.read();
+                        if (c2 == '/') {
+                            popState(); // back to previous
+                            doVerbatim("/"); // return slash verbatim
+                        } else {
+                            input.unread(c2);
+                        }
+                    }
+
+                    break;
+
+                // Return an ECMA single line comment, ending with end of line
+                case PARSE_STATE_ECMA_COMMENTL:
+
+                    // CRLF recognition
+                    if (c == '\r') {
+                        int c2 = input.read();
+                        if (c2 == '\n') {
+                            popState();
+                        }
+                        input.unread(c2);
+
+                        // LF only line end
+                    } else if (c == '\n') {
+                        popState();
+                    }
+
+                    break;
+                    
+                // What ???!!!
+                default:
+
+                    // we warn and go back to default state
+                    log.warn("doRead(): unknown state " + state);
+                    state = PARSE_STATE_ESP;
+
+                    break;
+
+            } // switch
+
+            // Exiting the switch normally we return the current character
+            return c;
+
+        } // for(;;)
+
+    }
+
+    /**
+     * Throw an IOException if the reader is not open
+     *
+     * @throws IOException if the reader is (already) closed
+     */
+    private void ensureOpen() throws IOException {
+        if (input == null) {
+            throw new IOException("Reader is closed");
+        }
+    }
+
+    /**
+     * Injects the call to write template text and checks whether the global
+     * <em>out</em> variable has also to be defined such that the writer is
+     * acquired on demand.
+     *
+     * @param startString Additional data to be injected as initial argument
+     *      to the <em>out.write</em> call written. If <code>null</code> just
+     *      the method call is injected.
+     *
+     * @throws IOException if the 'unreading' throws
+     */
+    private void startWrite(String startString) throws IOException {
+
+        // inject the out.write( part and the initial string
+        if (startString != null && startString.length() > 0) {
+            doVerbatim(startString);
+        }
+        doVerbatim("out.write(");
+
+        // if out is not set yet, we also acquire it now setting it
+        // globally
+        if (outUndefined) {
+            doVerbatim(outInitStatement);
+            outUndefined = false;
+        }
+    }
+
+    /**
+     * Injects a string into the input stream, sets the number of characters to
+     * return verbatim and change state. The state change only happens if we are
+     * not in verbatim state already. Else the current string is simply
+     * prepended to the previous inhjection. This is simply a convenience method
+     * ;-)
+     *
+     * @param verbatimString The string to inject into the input stream
+     * @throws IOException if the 'unreading' throws
+     */
+    private void doVerbatim(String verbatimString) throws IOException {
+
+        // Push 'back' into PushbackReader
+        input.unread(verbatimString.toCharArray());
+
+        // Set the number of characters to return verbatim
+        verbatimChars += verbatimString.length();
+
+        // Change state if not already in verbatim state
+        if (state != PARSE_STATE_VERBATIM) {
+            pushState(PARSE_STATE_VERBATIM);
+        }
+    }
+
+    /**
+     * Push the current state on stack and set to <code>newState</code>. This
+     * new state is also returned.
+     *
+     * @param newState the new state to set
+     * @return the new state set according to <code>newState</code>
+     */
+    private byte pushState(byte newState) {
+        stateStack.push(state);
+        return state = newState;
+    }
+
+    /**
+     * Sets the current state to the state stored at the top of the stack. If
+     * the stack is empty prior to this call, the default template text state is
+     * set. The method returns the state prior to setting to the new state.
+     *
+     * @return the state prior to calling this method
+     */
+    private byte popState() {
+        byte oldState = state;
+        state = stateStack.isEmpty() ? PARSE_STATE_ESP : stateStack.pop();
+        return oldState;
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableBase.java b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableBase.java
new file mode 100644
index 0000000..97671ec
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableBase.java
@@ -0,0 +1,86 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+package org.apache.sling.scripting.javascript.wrapper;
+
+import java.lang.reflect.Method;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.mozilla.javascript.NativeJavaObject;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptableObject;
+
+/** Base class for Scriptable objects, uses the NativeJavaObject wrapper to provide
+ *  default wrapping of methods and properties (SLING-397)
+ */
+public abstract class ScriptableBase extends ScriptableObject {
+    
+    private NativeJavaObject njo;
+    private final Set<String> jsMethods = getJsMethodNames();
+    
+    public static final String JSFUNC_PREFIX = "jsFunction_";
+    
+    protected Object getNative(String name, Scriptable start) {
+        final Object wrapped = getWrappedObject();
+        
+        if(wrapped == null) {
+            return Scriptable.NOT_FOUND;
+        }
+        
+        if(jsMethods.contains(name)) {
+            return Scriptable.NOT_FOUND;
+        }
+        
+        if(njo == null) {
+            synchronized (this) {
+                if(njo == null) {
+                    njo = new NativeJavaObject(start, wrapped, getStaticType());
+                }
+            }
+        }
+        
+        return njo.get(name, start);
+    }
+    
+    /** @return the Java object that we're wrapping, used to create a NativeJavaObject
+     *  instance for default wrapping.
+     */
+    protected abstract Object getWrappedObject();
+    
+    /** @return the static type to use for NativeJavaObject wrapping */
+    protected abstract Class<?> getStaticType();
+    
+    /** Used in testing, to check that the right wrapper is used. 
+     *  For some reason, defining the method here didn't work, it had to be
+     *  defined in all descendant classes.      
+     */
+    public abstract Class<?> jsGet_javascriptWrapperClass();
+    
+    /** @return the Set of method names that clazz defines, i.e. all public methods
+     *  with names that start with jsFunction_ */
+    private Set<String> getJsMethodNames() {
+        final Set<String> result = new HashSet<String>();
+        
+        for(Method m : getClass().getMethods()) {
+            if(m.getName().startsWith(JSFUNC_PREFIX)) {
+                result.add(m.getName().substring(JSFUNC_PREFIX.length()));
+            }
+        }
+        
+        return result;
+    }
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableCalendar.java b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableCalendar.java
new file mode 100644
index 0000000..8e2d57e
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableCalendar.java
@@ -0,0 +1,105 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+package org.apache.sling.scripting.javascript.wrapper;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+
+import org.apache.sling.scripting.javascript.helper.SlingWrapper;
+import org.mozilla.javascript.ScriptRuntime;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.Undefined;
+import org.apache.sling.commons.json.jcr.JsonItemWriter;
+
+@SuppressWarnings("serial")
+public class ScriptableCalendar extends ScriptableBase implements SlingWrapper {
+
+	public static final String CLASSNAME = "Calendar";
+	private SimpleDateFormat calendarFormat;
+	
+	/** Calendar is a class, not an interface - so we need to enumerate possible implementations here */
+    public static final Class<?> [] WRAPPED_CLASSES = { Calendar.class, GregorianCalendar.class };
+
+	private Calendar calendar;
+	
+    public Class<?>[] getWrappedClasses() {
+		return WRAPPED_CLASSES;
+	}
+
+    public void jsConstructor(Object o) {
+        this.calendar = (Calendar) o;
+    }
+	
+    @Override
+    public Object get(String name, Scriptable start) {
+
+        // builtin javascript properties (jsFunction_ etc.) have priority
+        final Object fromSuperclass = super.get(name, start);
+        if(fromSuperclass != Scriptable.NOT_FOUND) {
+            return fromSuperclass;
+        }
+
+        if(calendar == null) {
+            return Undefined.instance;
+        }
+        
+        if("date".equals(name)) {
+        	return ScriptRuntime.toObject(this, calendar.getTime());
+        }
+        
+        return getNative(name, start);
+    }
+    
+	@Override
+	protected Class<?> getStaticType() {
+		return Calendar.class;
+	}
+
+	@Override
+	protected Object getWrappedObject() {
+		return calendar;
+	}
+
+	@Override
+	public Class<?> jsGet_javascriptWrapperClass() {
+		return getClass();
+	}
+
+	@Override
+	public String getClassName() {
+		return CLASSNAME;
+	}
+
+	@Override
+	public String toString() {
+        if (calendarFormat == null) {
+            calendarFormat = new SimpleDateFormat(JsonItemWriter.ECMA_DATE_FORMAT, JsonItemWriter.DATE_FORMAT_LOCALE);
+        }
+        return calendarFormat.format(calendar.getTime());
+	}
+	
+    public Object unwrap() {
+        return calendar;
+    }
+
+    @SuppressWarnings("unchecked")
+	@Override
+    public Object getDefaultValue(Class typeHint) {
+    	return toString();
+    }
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableItemMap.java b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableItemMap.java
new file mode 100644
index 0000000..f8e9619
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableItemMap.java
@@ -0,0 +1,121 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.javascript.wrapper;
+
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import javax.jcr.Item;
+import javax.jcr.RepositoryException;
+
+import org.mozilla.javascript.ScriptRuntime;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptableObject;
+import org.mozilla.javascript.Undefined;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ScriptableItemMap extends ScriptableObject {
+
+    public static final String CLASSNAME = "ItemMap";
+
+    /** default log */
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    private Map<String, Item> items = new LinkedHashMap<String, Item>();
+
+    public ScriptableItemMap() {
+    }
+
+    public void jsConstructor(Object res) {
+        if (res instanceof Iterator) {
+            Iterator<?> itemIterator = (Iterator<?>) res;
+            while (itemIterator.hasNext()) {
+                Item item = (Item) itemIterator.next();
+                try {
+                    items.put(item.getName(), item);
+                } catch (RepositoryException re) {
+                    log.error("ScriptableItemMap<init>: Cannot get name of item "
+                        + item, re);
+                }
+            }
+        }
+    }
+
+    @Override
+    public String getClassName() {
+        return CLASSNAME;
+    }
+
+    @Override
+    public boolean has(int index, Scriptable start) {
+        return getItem(index) != null;
+    }
+
+    @Override
+    public boolean has(String name, Scriptable start) {
+        return items.containsKey(name);
+    }
+
+    @Override
+    public Object get(int index, Scriptable start) {
+        Item item = getItem(index);
+        if (item != null) {
+            return ScriptRuntime.toObject(this, item);
+        }
+
+        return Undefined.instance;
+    }
+
+    @Override
+    public Object get(String name, Scriptable start) {
+        // special provision for the "length" property to simulate an array
+        if ("length".equals(name)) {
+            return ScriptRuntime.toNumber(this.items.keySet().size()+"");
+        }
+
+        Item item = items.get(name);
+        Object result = Undefined.instance;
+        if (item != null) {
+            result = ScriptRuntime.toObject(this, item);
+        }
+
+        return result;
+    }
+
+    @Override
+    public Object[] getIds() {
+        return items.keySet().toArray();
+    }
+
+    private Item getItem(int index) {
+        if (index < 0 || index >= items.size()) {
+            return null;
+        }
+
+        Iterator<Item> itemsIter = items.values().iterator();
+        while (itemsIter.hasNext() && index > 0) {
+            itemsIter.next();
+            index--;
+        }
+
+        return itemsIter.hasNext() ? itemsIter.next() : null;
+    }
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableNode.java b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableNode.java
new file mode 100644
index 0000000..80a641e
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableNode.java
@@ -0,0 +1,432 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+package org.apache.sling.scripting.javascript.wrapper;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.jcr.Node;
+import javax.jcr.NodeIterator;
+import javax.jcr.Property;
+import javax.jcr.PropertyIterator;
+import javax.jcr.PropertyType;
+import javax.jcr.RepositoryException;
+import javax.jcr.Value;
+import javax.jcr.ValueFormatException;
+import javax.jcr.nodetype.NodeType;
+
+import org.apache.sling.jcr.resource.JcrResourceUtil;
+import org.apache.sling.scripting.javascript.helper.SlingWrapper;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.NativeArray;
+import org.mozilla.javascript.ScriptRuntime;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.Undefined;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A wrapper for JCR nodes that exposes all properties and child nodes as
+ * properties of a Javascript object.
+ */
+@SuppressWarnings("serial")
+public class ScriptableNode extends ScriptableBase implements SlingWrapper {
+
+    public static final String CLASSNAME = "Node";
+    public static final Class<?> [] WRAPPED_CLASSES = { Node.class };
+
+    /** default log */
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    private Node node;
+
+    public void jsConstructor(Object res) {
+        this.node = (Node) res;
+    }
+
+    public String getClassName() {
+        return CLASSNAME;
+    }
+
+    public Class<?> [] getWrappedClasses() {
+        return WRAPPED_CLASSES;
+    }
+    
+    @Override
+    protected Class<?> getStaticType() {
+        return Node.class;
+    }
+
+    @Override
+    protected Object getWrappedObject() {
+        return node;
+    }
+    
+    public Object jsFunction_addNode(String path, String primaryType) throws RepositoryException {
+        Node n = null;
+        if(primaryType == null || "undefined".equals(primaryType)) {
+            n = node.addNode(path);
+        } else {
+            n = node.addNode(path, primaryType);
+        }
+
+        final Object result = ScriptRuntime.toObject(this, n);
+        return result;
+    }
+
+    public Object jsFunction_getNode(String path) throws RepositoryException {
+        return ScriptRuntime.toObject(this, node.getNode(path));
+    }
+
+    public Object jsFunction_getChildren() {
+        try {
+            return toScriptableItemMap(node.getNodes());
+        } catch (RepositoryException re) {
+            log.warn("Cannot get children of " + jsFunction_getPath(), re);
+            return toScriptableItemMap(null);
+        }
+    }
+
+    public Object jsFunction_getNodes(String namePattern) {
+        try {
+            NodeIterator iter = null;
+            if(namePattern == null || "undefined".equals(namePattern)) {
+                iter = node.getNodes();
+            } else {
+                iter = node.getNodes(namePattern);
+            }
+            return toScriptableItemMap(iter);
+        } catch (RepositoryException re) {
+            log.warn("Cannot get children of " + jsFunction_getPath() + " with pattern " + namePattern, re);
+            return toScriptableItemMap(null);
+        }
+    }
+    
+    public Object jsFunction_getProperties() {
+        try {
+            return toScriptableItemMap(node.getProperties());
+        } catch (RepositoryException re) {
+            log.warn("Cannot get properties of " + jsFunction_getPath(), re);
+            return toScriptableItemMap(null);
+        }
+    }
+
+    public Object jsFunction_getPrimaryItem() {
+        try {
+            return ScriptRuntime.toObject(this, node.getPrimaryItem());
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+    
+    public Object jsFunction_getProperty(String name) throws RepositoryException {
+        Object[] args = { node.getProperty(name) };
+        return ScriptRuntime.newObject(Context.getCurrentContext(), this,
+            ScriptableProperty.CLASSNAME, args);
+    }
+
+    public String jsFunction_getUUID() {
+        try {
+            return node.getUUID();
+        } catch (RepositoryException re) {
+            return "";
+        }
+    }
+
+    public int jsFunction_getIndex() {
+        try {
+            return node.getIndex();
+        } catch (RepositoryException re) {
+            return 1;
+        }
+    }
+
+    public Iterator<?> jsFunction_getReferences() {
+        try {
+            return node.getReferences();
+        } catch (RepositoryException re) {
+            return Collections.EMPTY_LIST.iterator();
+        }
+    }
+
+    public Object jsFunction_getPrimaryNodeType() {
+        try {
+            return node.getPrimaryNodeType();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public NodeType[] jsFunction_getMixinNodeTypes() {
+        try {
+            return node.getMixinNodeTypes();
+        } catch (RepositoryException re) {
+            return new NodeType[0];
+        }
+    }
+
+    public Object jsFunction_getDefinition() {
+        try {
+            return node.getDefinition();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public boolean jsFunction_getCheckedOut() {
+        try {
+            return node.isCheckedOut();
+        } catch (RepositoryException re) {
+            return false;
+        }
+    }
+
+    public Object jsFunction_getVersionHistory() {
+        try {
+            return ScriptRuntime.toObject(this, node.getVersionHistory());
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public Object jsFunction_getBaseVersion() {
+        try {
+            return ScriptRuntime.toObject(this, node.getBaseVersion());
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public Object jsFunction_getLock() {
+        try {
+            return node.getLock();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public boolean jsFunction_getLocked() {
+        try {
+            return node.isLocked();
+        } catch (RepositoryException re) {
+            return false;
+        }
+    }
+
+    public Object jsFunction_getSession() {
+        try {
+            return node.getSession();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public String jsFunction_getPath() {
+        try {
+            return node.getPath();
+        } catch (RepositoryException e) {
+            return node.toString();
+        }
+    }
+
+    public String jsFunction_getName() {
+        try {
+            return node.getName();
+        } catch (RepositoryException e) {
+            return node.toString();
+        }
+    }
+    
+    public Object jsFunction_getParent() {
+        try {
+            return ScriptRuntime.toObject(this, node.getParent());
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public int jsFunction_getDepth() {
+        try {
+            return node.getDepth();
+        } catch (RepositoryException re) {
+            return -1;
+        }
+    }
+
+    public boolean jsFunction_getNew() {
+        return node.isNew();
+    }
+
+    public boolean jsFunction_getModified() {
+        return node.isModified();
+    }
+    
+    public void jsFunction_remove() throws RepositoryException {
+        node.remove();
+    }
+
+    public boolean jsFunction_hasNode(String path) throws RepositoryException {
+        return node.hasNode(path);
+    }
+
+    /**
+     * Gets the value of a (Javascript) property or child node. If there is a single single-value
+     * JCR property of this node, return its string value. If there are multiple properties
+     * of the same name or child nodes of the same name, return an array.
+     */
+    @Override
+    public Object get(String name, Scriptable start) {
+
+        // builtin javascript properties (jsFunction_ etc.) have priority
+        final Object fromSuperclass = super.get(name, start);
+        if(fromSuperclass != Scriptable.NOT_FOUND) {
+            return fromSuperclass;
+        }
+
+        if(node == null) {
+            return Undefined.instance;
+        }
+
+        final List<Scriptable> items = new ArrayList<Scriptable>();
+
+        // Add all matching nodes to result
+        try {
+            NodeIterator it = node.getNodes(name);
+            while (it.hasNext()) {
+                items.add(ScriptRuntime.toObject(this, it.nextNode()));
+            }
+        } catch (RepositoryException e) {
+            log.debug("RepositoryException while collecting Node children",e);
+        }
+
+        // Add all matching properties to result
+        try {
+            PropertyIterator it = node.getProperties(name);
+            while (it.hasNext()) {
+                Property prop = it.nextProperty();
+                int type = prop.getType();
+                if (prop.getDefinition().isMultiple()) {
+                    Value[] values = prop.getValues();
+                    for (int i=0;i<values.length;i++) {
+                        items.add(wrap(values[i]));
+                    }
+                } else {
+                    if (type==PropertyType.REFERENCE) {
+                        items.add(ScriptRuntime.toObject(this, prop.getNode()));
+                    } else {
+                        items.add(wrap(prop.getValue()));
+                    }
+                }
+            }
+        } catch (RepositoryException e) {
+            log.debug("RepositoryException while collecting Node properties",e);
+        }
+
+        if (items.size()==0) {
+            return getNative(name, start);
+            
+        } else if (items.size()==1) {
+            return items.iterator().next();
+            
+        } else {
+            NativeArray result = new NativeArray(items.toArray());
+            ScriptRuntime.setObjectProtoAndParent(result, this);
+            return result;
+        }
+    }
+
+    /** Wrap JCR Values in a simple way */
+    private Scriptable wrap(Value value) throws ValueFormatException,
+            IllegalStateException, RepositoryException {
+        return ScriptRuntime.toObject(this, JcrResourceUtil.toJavaObject(value));
+    }
+
+    @Override
+    public Object[] getIds() {
+        Collection<String> ids = new ArrayList<String>();
+        if(node != null) {
+            try {
+                PropertyIterator pit = node.getProperties();
+                while (pit.hasNext()) {
+                    ids.add(pit.nextProperty().getName());
+                }
+            } catch (RepositoryException e) {
+                //do nothing, just do not list properties
+            }
+            try {
+                NodeIterator nit = node.getNodes();
+                while (nit.hasNext()) {
+                    ids.add(nit.nextNode().getName());
+                }
+            } catch (RepositoryException e) {
+                //do nothing, just do not list child nodes
+            }
+        }
+        return ids.toArray();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Object getDefaultValue(Class typeHint) {
+        try {
+            return node.getPath();
+        } catch(Exception e) {
+            return null;
+        }
+    }
+
+    @Override
+    public boolean has(String name, Scriptable start) {
+        try {
+            // TODO should this take into account our jsFunction_ members?
+            return node.hasProperty(name) || node.hasNode(name);
+        } catch (RepositoryException e) {
+            return false;
+        }
+    }
+
+    public Class<?> jsGet_javascriptWrapperClass() {
+        return getClass();
+    }
+    
+    @Override
+    public String toString() {
+        try {
+            return node.getPath();
+        } catch (RepositoryException e) {
+            return node.toString();
+        }
+    }
+
+    // ---------- Wrapper interface --------------------------------------------
+
+    // returns the wrapped node
+    public Object unwrap() {
+        return node;
+    }
+    
+    //---------- Helper -------------------------------------------------------
+    
+    private Object toScriptableItemMap(Iterator<?> iter) {
+        Object[] args = (iter != null) ? new Object[] { iter } : null;
+        return ScriptRuntime.newObject(Context.getCurrentContext(), this,
+            ScriptableItemMap.CLASSNAME, args);
+    }
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptablePrintWriter.java b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptablePrintWriter.java
new file mode 100644
index 0000000..d1db5b1
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptablePrintWriter.java
@@ -0,0 +1,180 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+package org.apache.sling.scripting.javascript.wrapper;
+
+import java.io.PrintWriter;
+import java.util.Locale;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.sling.api.scripting.SlingBindings;
+import org.apache.sling.scripting.javascript.helper.SlingWrapper;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Function;
+import org.mozilla.javascript.ScriptRuntime;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptableObject;
+import org.mozilla.javascript.Wrapper;
+
+public class ScriptablePrintWriter extends ScriptableObject implements SlingWrapper {
+
+    public static final String CLASSNAME = "PrintWriter";
+    public static final Class<?> [] WRAPPED_CLASSES = { PrintWriter.class };
+
+    private PrintWriter writer;
+
+    // the locale to use for printf
+    private Locale locale;
+
+    public ScriptablePrintWriter() {
+    }
+
+    public ScriptablePrintWriter(PrintWriter writer) {
+        this.writer = writer;
+    }
+
+    public void jsConstructor(Object res) {
+        this.writer = (PrintWriter) res;
+    }
+
+    @Override
+    public String getClassName() {
+        return CLASSNAME;
+    }
+
+    public Class<?> [] getWrappedClasses() {
+        return WRAPPED_CLASSES;
+    }
+    
+    // print args to writer if any
+    // this method supports write(Object)
+    public static void jsFunction_write(Context cx, Scriptable thisObj,
+            Object[] args, Function funObj) {
+        print(thisObj, args);
+    }
+
+    // print args to writer if any
+    // this method supports print(Object)
+    public static void jsFunction_print(Context cx, Scriptable thisObj,
+            Object[] args, Function funObj) {
+        print(thisObj, args);
+    }
+
+    // print a formatted string to the writer. The first arg is used as the
+    // formatter Locale if it is a Locale instance. The next argument is the
+    // format string followed by format arguments.
+    // This method supports printf(Locale, String, Object...) and
+    // printf(String, Object...)
+    public static void jsFunction_printf(Context cx, Scriptable thisObj,
+            Object[] args, Function funObj) {
+
+        if (args.length > 0) {
+
+            // the index of the next argument to consider
+            int nextIdx = 0;
+
+            // the local for printf
+            Locale locale = null;
+
+            if (args[nextIdx] instanceof Locale) {
+
+                // the Locale is the first argument, use it an increment idx
+                locale = (Locale) args[nextIdx];
+                nextIdx++;
+
+            } else {
+
+                // get the per-HTTP request local or the default locale
+                locale = ((ScriptablePrintWriter) thisObj).getLocale();
+            }
+
+            // only continue, if there is at least an other argument
+            // containing the format string
+            if (args.length > nextIdx) {
+
+                // the format string
+                String format = ScriptRuntime.toString(args[nextIdx]);
+
+                // arguments starting after that are formatting arguments
+                nextIdx++;
+                Object[] formatArgs = new Object[args.length - nextIdx];
+                System.arraycopy(args, nextIdx, formatArgs, 0,
+                    formatArgs.length);
+
+                // now get the writer and call printf
+                PrintWriter writer = ((ScriptablePrintWriter) thisObj).writer;
+                writer.printf(locale, format, formatArgs);
+            }
+        }
+    }
+
+    // print args to the writer (if any) and append a line feed
+    // this method supports println(Object)
+    public static void jsFunction_println(Context cx, Scriptable thisObj,
+            Object[] args, Function funObj) {
+        print(thisObj, args).println();
+    }
+
+    // ---------- Wrapper interface --------------------------------------------
+
+    // returns the wrapped print writer
+    public Object unwrap() {
+        return writer;
+    }
+
+    // ---------- internal helper ----------------------------------------------
+
+    // print all arguments as strings to the writer
+    private static PrintWriter print(Object thisObj, Object[] args) {
+        PrintWriter writer = ((ScriptablePrintWriter) thisObj).writer;
+        for (Object arg : args) {
+            writer.print(ScriptRuntime.toString(arg));
+        }
+        return writer;
+    }
+
+    // helper method to return the locale to use for this instance:
+    //    - if the global scope has a "request" object which is a
+    //      HttpServletRequest, we call getLocale() on that object
+    //    - Otherwise or if getLocale returns null, we use the platform default
+    private Locale getLocale() {
+        if (locale == null) {
+            
+            try {
+                // check whether we have a request object which has the locale
+                Object reqObj = ScriptRuntime.name(Context.getCurrentContext(),
+                    this, SlingBindings.REQUEST);
+                if (reqObj instanceof Wrapper) {
+                    Object wrapped = ((Wrapper) reqObj).unwrap();
+                    if (wrapped instanceof HttpServletRequest) {
+                        locale = ((HttpServletRequest) wrapped).getLocale();
+                    }
+                }
+            } catch (Exception e) {
+                // ignore any exceptions resulting from this and use default
+            }
+
+            // default, if the no request locale or no request is available
+            if (locale == null) {
+                locale = Locale.getDefault();
+            }
+
+        }
+
+        return locale;
+    }
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableProperty.java b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableProperty.java
new file mode 100644
index 0000000..438cad6
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableProperty.java
@@ -0,0 +1,304 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.javascript.wrapper;
+
+import javax.jcr.Property;
+import javax.jcr.PropertyType;
+import javax.jcr.RepositoryException;
+
+import org.apache.sling.scripting.javascript.helper.SlingWrapper;
+import org.mozilla.javascript.ScriptRuntime;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.Undefined;
+
+/** Wrap a JCR Property as a Scriptable */
+@SuppressWarnings("serial")
+public class ScriptableProperty extends ScriptableBase implements SlingWrapper {
+
+    public static final String CLASSNAME = "Property";
+
+    public static final Class<?>[] WRAPPED_CLASSES = { Property.class };
+
+    private Property property;
+
+    public ScriptableProperty() {
+    }
+
+    public void jsConstructor(Object res) {
+        this.property = (Property) res;
+    }
+
+    @Override
+    public String getClassName() {
+        return CLASSNAME;
+    }
+
+    public Class<?>[] getWrappedClasses() {
+        return WRAPPED_CLASSES;
+    }
+
+    public Object jsGet_value() {
+        try {
+            return property.getValue();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public Object jsGet_values() {
+        try {
+            return property.getValues();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public Object jsGet_string() {
+        try {
+            return property.getString();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public Object jsGet_stream() {
+        try {
+            return property.getStream();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public Object jsGet_long() {
+        try {
+            return property.getLong();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public Object jsGet_double() {
+        try {
+            return property.getDouble();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public Object jsGet_date() {
+        try {
+            return property.getDate();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public Object jsGet_boolean() {
+        try {
+            return property.getBoolean();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public Object jsGet_node() {
+        try {
+            return ScriptRuntime.toObject(this, property.getValue());
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public Object jsGet_length() {
+        try {
+            return property.getLength();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public long[] jsGet_lengths() {
+        try {
+            return property.getLengths();
+        } catch (RepositoryException re) {
+            return new long[0];
+        }
+    }
+
+    public Object jsGet_definition() {
+        try {
+            return property.getDefinition();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public int getType() {
+        try {
+            return property.getType();
+        } catch (RepositoryException re) {
+            return PropertyType.UNDEFINED;
+        }
+    }
+
+    public Object jsGet_session() {
+        try {
+            return property.getSession();
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public String jsGet_path() {
+        try {
+            return property.getPath();
+        } catch (RepositoryException e) {
+            return property.toString();
+        }
+    }
+
+    public String jsGet_name() {
+        try {
+            return property.getName();
+        } catch (RepositoryException e) {
+            return property.toString();
+        }
+    }
+
+    public Object jsGet_parent() {
+        try {
+            return ScriptRuntime.toObject(this, property.getParent());
+        } catch (RepositoryException re) {
+            return Undefined.instance;
+        }
+    }
+
+    public int jsGet_depth() {
+        try {
+            return property.getDepth();
+        } catch (RepositoryException re) {
+            return -1;
+        }
+    }
+
+    public boolean jsGet_new() {
+        return property.isNew();
+    }
+
+    public boolean jsGet_modified() {
+        return property.isModified();
+    }
+
+    public Class<?> jsGet_javascriptWrapperClass() {
+        return getClass();
+    }
+    
+    public Object jsFunction_valueOf(String hint) {
+        if ("undefined".equals(hint)) {
+            
+            try {
+                switch (property.getType()) {
+                    case PropertyType.BOOLEAN:
+                        return property.getBoolean();
+                    case PropertyType.DATE:
+                        return property.getDate();
+                    case PropertyType.DOUBLE:
+                        return property.getDouble();
+                    case PropertyType.LONG:
+                        return property.getLong();
+                    default:
+                        return toString();
+                }
+            } catch (RepositoryException re) {
+                // don't care, just return the string value
+                return toString();
+            }
+            
+        } else if ("object".equals(hint)) {
+            // return this as a Scriptable :-)
+            return this;
+            
+        } else if ("function".equals(hint)) {
+            // cannot return this as a Function
+            return Undefined.instance;
+            
+        } else if ("boolean".equals(hint)) {
+            // boolean value
+            try {
+                property.getBoolean();
+            } catch (RepositoryException re) {
+                return false;
+            }
+            
+        } else if ("number".equals(hint)) {
+            // numeric value
+            try {
+                property.getDouble();
+            } catch (RepositoryException re) {
+                return 0.0;
+            }
+        }
+
+        // unknown hint or "string"
+        return toString();
+    }
+    
+    @Override
+    public Object get(String name, Scriptable start) {
+        final Object fromSuperclass = super.get(name, start);
+        if(fromSuperclass != Scriptable.NOT_FOUND) {
+            return fromSuperclass;
+        }
+
+        if(property == null) {
+            return Undefined.instance;
+        }
+        
+        return getNative(name, start);
+    }
+
+    public Object jsFunction_toString() {
+        return toString();
+    }
+
+    @Override
+    public String toString() {
+        try {
+            return property.getValue().getString();
+        } catch (RepositoryException e) {
+            return property.toString();
+        }
+    }
+
+    // ---------- Wrapper interface --------------------------------------------
+
+    public Object unwrap() {
+        return property;
+    }
+
+    @Override
+    protected Class<?> getStaticType() {
+        return Property.class;
+    }
+
+    @Override
+    protected Object getWrappedObject() {
+        return property;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableResource.java b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableResource.java
new file mode 100644
index 0000000..df6452a
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableResource.java
@@ -0,0 +1,166 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+package org.apache.sling.scripting.javascript.wrapper;
+
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.scripting.javascript.helper.SlingWrapper;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Function;
+import org.mozilla.javascript.ScriptRuntime;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptableObject;
+import org.mozilla.javascript.Undefined;
+import org.mozilla.javascript.Wrapper;
+
+/**
+ * Resource in JavaScript has following signature: [Object] getData(); [Object]
+ * data [Item] getItem(); [Item] item [String] getResourceType(); [String] type
+ * [String] getPath(); [String] path
+ */
+public class ScriptableResource extends ScriptableObject implements SlingWrapper {
+
+    public static final String CLASSNAME = "Resource";
+    public static final Class<?> [] WRAPPED_CLASSES = { Resource.class };
+
+    private Resource resource;
+
+    public ScriptableResource() {
+    }
+
+    public ScriptableResource(Resource resource) {
+        this.resource = resource;
+    }
+
+    public void jsConstructor(Object res) {
+        this.resource = (Resource) res;
+    }
+
+    public Class<?> [] getWrappedClasses() {
+        return WRAPPED_CLASSES;
+    }
+
+    @Override
+    public String getClassName() {
+        return CLASSNAME;
+    }
+
+    public Object jsFunction_getObject() {
+        return toJS(resource.adaptTo(Object.class));
+    }
+
+    public String jsFunction_getResourceType() {
+        return resource.getResourceType();
+    }
+
+    public String jsGet_type() {
+        return this.jsFunction_getResourceType();
+    }
+
+    public String jsFunction_getPath() {
+        return resource.getPath();
+    }
+
+    public String jsGet_path() {
+        return this.jsFunction_getPath();
+    }
+
+    public Object jsFunction_getMetadata() {
+        return toJS(resource.getResourceMetadata());
+    }
+
+    public Object jsGet_meta() {
+        return jsFunction_getMetadata();
+    }
+
+    public Object jsFunction_getResourceResolver() {
+        return toJS(resource.getResourceResolver());
+    }
+
+    public Object jsGet_resourceResolver() {
+        return jsFunction_getResourceResolver();
+    }
+
+    public static Object jsFunction_adaptTo(Context cx, Scriptable thisObj,
+            Object[] args, Function funObj) {
+
+        // get and unwrap the argument
+        Object arg = (args.length > 0) ? args[0] : null;
+        while (arg instanceof Wrapper) {
+            arg = ((Wrapper) arg).unwrap();
+        }
+
+        // try to get the Class object for the argument
+        Class<?> adapter = null;
+        if (arg instanceof Class) {
+
+            adapter = (Class<?>) arg;
+
+        } else if (arg != null && arg != Undefined.instance) {
+
+            // try loading the class from the String
+            String className = ScriptRuntime.toString(arg);
+            try {
+                ClassLoader loader = Thread.currentThread().getContextClassLoader();
+                if (loader == null) {
+                    loader = thisObj.getClass().getClassLoader();
+                }
+                adapter = Class.forName(className, true, loader);
+            } catch (Exception e) {
+                // TODO: log exception
+            }
+
+        }
+
+        if (adapter != null) {
+            ScriptableResource sr = (ScriptableResource) thisObj;
+            return sr.toJS(sr.resource.adaptTo(adapter));
+        }
+
+        return Undefined.instance;
+    }
+
+    public Class<?> jsGet_javascriptWrapperClass() {
+        return getClass();
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public Object getDefaultValue(Class typeHint) {
+        return resource.getPath();
+    }
+
+    public void setResource(Resource entry) {
+        this.resource = entry;
+    }
+
+    // ---------- Wrapper interface --------------------------------------------
+
+    // returns the wrapped resource
+    public Object unwrap() {
+        return resource;
+    }
+
+    //---------- Internal helper ----------------------------------------------
+
+    private Object toJS(Object javaObject) {
+        if (javaObject == null) {
+            return Undefined.instance;
+        }
+
+        return ScriptRuntime.toObject(this, javaObject);
+    }
+}
diff --git a/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableVersion.java b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableVersion.java
new file mode 100644
index 0000000..27b26f1
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableVersion.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+package org.apache.sling.scripting.javascript.wrapper;
+
+import javax.jcr.version.Version;
+
+/** Scriptable wrapper for the JCR Version class */
+@SuppressWarnings("serial")
+public class ScriptableVersion extends ScriptableNode {
+
+    public static final String CLASSNAME = "Version";
+    public static final Class<?> [] WRAPPED_CLASSES = { Version.class };
+    
+    private Version version;
+    
+    @Override
+    public void jsConstructor(Object res) {
+        super.jsConstructor(res);
+        version = (Version)res;
+    }
+
+    @Override
+    protected Class<?> getStaticType() {
+        return Version.class;
+    }
+
+    @Override
+    public String getClassName() {
+        return CLASSNAME;
+    }
+
+    @Override
+    public Class<?>[] getWrappedClasses() {
+        return WRAPPED_CLASSES;
+    }
+
+    @Override
+    protected Object getWrappedObject() {
+        return version;
+    }
+    
+    public Class<?> jsGet_javascriptWrapperClass() {
+        return getClass();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableVersionHistory.java b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableVersionHistory.java
new file mode 100644
index 0000000..ed23f5f
--- /dev/null
+++ b/src/main/java/org/apache/sling/scripting/javascript/wrapper/ScriptableVersionHistory.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+package org.apache.sling.scripting.javascript.wrapper;
+
+import javax.jcr.version.VersionHistory;
+
+/** Scriptable wrapper for the JCR VersionHistory class */
+@SuppressWarnings("serial")
+public class ScriptableVersionHistory extends ScriptableNode {
+
+    public static final String CLASSNAME = "VersionHistory";
+    public static final Class<?> [] WRAPPED_CLASSES = { VersionHistory.class };
+    
+    private VersionHistory versionHistory;
+    
+    @Override
+    public void jsConstructor(Object res) {
+        super.jsConstructor(res);
+        versionHistory = (VersionHistory)res;
+    }
+
+    @Override
+    protected Class<?> getStaticType() {
+        return VersionHistory.class;
+    }
+
+    @Override
+    public String getClassName() {
+        return CLASSNAME;
+    }
+
+    @Override
+    public Class<?>[] getWrappedClasses() {
+        return WRAPPED_CLASSES;
+    }
+
+    @Override
+    protected Object getWrappedObject() {
+        return versionHistory;
+    }
+    
+    public Class<?> jsGet_javascriptWrapperClass() {
+        return getClass();
+    }
+}
\ No newline at end of file
diff --git a/src/main/resources/META-INF/DISCLAIMER b/src/main/resources/META-INF/DISCLAIMER
new file mode 100644
index 0000000..90850c2
--- /dev/null
+++ b/src/main/resources/META-INF/DISCLAIMER
@@ -0,0 +1,7 @@
+Apache Sling is an effort undergoing incubation at The Apache Software Foundation (ASF),
+sponsored by the Apache Jackrabbit PMC. Incubation is required of all newly accepted
+projects until a further review indicates that the infrastructure, communications,
+and decision making process have stabilized in a manner consistent with other
+successful ASF projects. While incubation status is not necessarily a reflection of
+the completeness or stability of the code, it does indicate that the project has yet
+to be fully endorsed by the ASF.
\ No newline at end of file
diff --git a/src/main/resources/META-INF/LICENSE b/src/main/resources/META-INF/LICENSE
new file mode 100644
index 0000000..884d3e7
--- /dev/null
+++ b/src/main/resources/META-INF/LICENSE
@@ -0,0 +1,681 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
+
+
+APACHE SLING SUBCOMPONENTS:
+
+Apache Sling includes subcomponents with separate copyright notices and
+license terms. Your use of these subcomponents is subject to the terms
+and conditions of the following licenses.
+
+Rhino
+
+                          MOZILLA PUBLIC LICENSE
+                                Version 1.1
+
+                              ---------------
+
+   1. Definitions.
+
+     1.0.1. "Commercial Use" means distribution or otherwise making the
+     Covered Code available to a third party.
+
+     1.1. "Contributor" means each entity that creates or contributes to
+     the creation of Modifications.
+
+     1.2. "Contributor Version" means the combination of the Original
+     Code, prior Modifications used by a Contributor, and the Modifications
+     made by that particular Contributor.
+
+     1.3. "Covered Code" means the Original Code or Modifications or the
+     combination of the Original Code and Modifications, in each case
+     including portions thereof.
+
+     1.4. "Electronic Distribution Mechanism" means a mechanism generally
+     accepted in the software development community for the electronic
+     transfer of data.
+
+     1.5. "Executable" means Covered Code in any form other than Source
+     Code.
+
+     1.6. "Initial Developer" means the individual or entity identified
+     as the Initial Developer in the Source Code notice required by Exhibit
+     A.
+
+     1.7. "Larger Work" means a work which combines Covered Code or
+     portions thereof with code not governed by the terms of this License.
+
+     1.8. "License" means this document.
+
+     1.8.1. "Licensable" means having the right to grant, to the maximum
+     extent possible, whether at the time of the initial grant or
+     subsequently acquired, any and all of the rights conveyed herein.
+
+     1.9. "Modifications" means any addition to or deletion from the
+     substance or structure of either the Original Code or any previous
+     Modifications. When Covered Code is released as a series of files, a
+     Modification is:
+          A. Any addition to or deletion from the contents of a file
+          containing Original Code or previous Modifications.
+
+          B. Any new file that contains any part of the Original Code or
+          previous Modifications.
+
+     1.10. "Original Code" means Source Code of computer software code
+     which is described in the Source Code notice required by Exhibit A as
+     Original Code, and which, at the time of its release under this
+     License is not already Covered Code governed by this License.
+
+     1.10.1. "Patent Claims" means any patent claim(s), now owned or
+     hereafter acquired, including without limitation,  method, process,
+     and apparatus claims, in any patent Licensable by grantor.
+
+     1.11. "Source Code" means the preferred form of the Covered Code for
+     making modifications to it, including all modules it contains, plus
+     any associated interface definition files, scripts used to control
+     compilation and installation of an Executable, or source code
+     differential comparisons against either the Original Code or another
+     well known, available Covered Code of the Contributor's choice. The
+     Source Code can be in a compressed or archival form, provided the
+     appropriate decompression or de-archiving software is widely available
+     for no charge.
+
+     1.12. "You" (or "Your")  means an individual or a legal entity
+     exercising rights under, and complying with all of the terms of, this
+     License or a future version of this License issued under Section 6.1.
+     For legal entities, "You" includes any entity which controls, is
+     controlled by, or is under common control with You. For purposes of
+     this definition, "control" means (a) the power, direct or indirect,
+     to cause the direction or management of such entity, whether by
+     contract or otherwise, or (b) ownership of more than fifty percent
+     (50%) of the outstanding shares or beneficial ownership of such
+     entity.
+
+   2. Source Code License.
+
+     2.1. The Initial Developer Grant.
+     The Initial Developer hereby grants You a world-wide, royalty-free,
+     non-exclusive license, subject to third party intellectual property
+     claims:
+          (a)  under intellectual property rights (other than patent or
+          trademark) Licensable by Initial Developer to use, reproduce,
+          modify, display, perform, sublicense and distribute the Original
+          Code (or portions thereof) with or without Modifications, and/or
+          as part of a Larger Work; and
+
+          (b) under Patents Claims infringed by the making, using or
+          selling of Original Code, to make, have made, use, practice,
+          sell, and offer for sale, and/or otherwise dispose of the
+          Original Code (or portions thereof).
+
+          (c) the licenses granted in this Section 2.1(a) and (b) are
+          effective on the date Initial Developer first distributes
+          Original Code under the terms of this License.
+
+          (d) Notwithstanding Section 2.1(b) above, no patent license is
+          granted: 1) for code that You delete from the Original Code; 2)
+          separate from the Original Code;  or 3) for infringements caused
+          by: i) the modification of the Original Code or ii) the
+          combination of the Original Code with other software or devices.
+
+     2.2. Contributor Grant.
+     Subject to third party intellectual property claims, each Contributor
+     hereby grants You a world-wide, royalty-free, non-exclusive license
+
+          (a)  under intellectual property rights (other than patent or
+          trademark) Licensable by Contributor, to use, reproduce, modify,
+          display, perform, sublicense and distribute the Modifications
+          created by such Contributor (or portions thereof) either on an
+          unmodified basis, with other Modifications, as Covered Code
+          and/or as part of a Larger Work; and
+
+          (b) under Patent Claims infringed by the making, using, or
+          selling of  Modifications made by that Contributor either alone
+          and/or in combination with its Contributor Version (or portions
+          of such combination), to make, use, sell, offer for sale, have
+          made, and/or otherwise dispose of: 1) Modifications made by that
+          Contributor (or portions thereof); and 2) the combination of
+          Modifications made by that Contributor with its Contributor
+          Version (or portions of such combination).
+
+          (c) the licenses granted in Sections 2.2(a) and 2.2(b) are
+          effective on the date Contributor first makes Commercial Use of
+          the Covered Code.
+
+          (d)    Notwithstanding Section 2.2(b) above, no patent license is
+          granted: 1) for any code that Contributor has deleted from the
+          Contributor Version; 2)  separate from the Contributor Version;
+          3)  for infringements caused by: i) third party modifications of
+          Contributor Version or ii)  the combination of Modifications made
+          by that Contributor with other software  (except as part of the
+          Contributor Version) or other devices; or 4) under Patent Claims
+          infringed by Covered Code in the absence of Modifications made by
+          that Contributor.
+
+   3. Distribution Obligations.
+
+     3.1. Application of License.
+     The Modifications which You create or to which You contribute are
+     governed by the terms of this License, including without limitation
+     Section 2.2. The Source Code version of Covered Code may be
+     distributed only under the terms of this License or a future version
+     of this License released under Section 6.1, and You must include a
+     copy of this License with every copy of the Source Code You
+     distribute. You may not offer or impose any terms on any Source Code
+     version that alters or restricts the applicable version of this
+     License or the recipients' rights hereunder. However, You may include
+     an additional document offering the additional rights described in
+     Section 3.5.
+
+     3.2. Availability of Source Code.
+     Any Modification which You create or to which You contribute must be
+     made available in Source Code form under the terms of this License
+     either on the same media as an Executable version or via an accepted
+     Electronic Distribution Mechanism to anyone to whom you made an
+     Executable version available; and if made available via Electronic
+     Distribution Mechanism, must remain available for at least twelve (12)
+     months after the date it initially became available, or at least six
+     (6) months after a subsequent version of that particular Modification
+     has been made available to such recipients. You are responsible for
+     ensuring that the Source Code version remains available even if the
+     Electronic Distribution Mechanism is maintained by a third party.
+
+     3.3. Description of Modifications.
+     You must cause all Covered Code to which You contribute to contain a
+     file documenting the changes You made to create that Covered Code and
+     the date of any change. You must include a prominent statement that
+     the Modification is derived, directly or indirectly, from Original
+     Code provided by the Initial Developer and including the name of the
+     Initial Developer in (a) the Source Code, and (b) in any notice in an
+     Executable version or related documentation in which You describe the
+     origin or ownership of the Covered Code.
+
+     3.4. Intellectual Property Matters
+          (a) Third Party Claims.
+          If Contributor has knowledge that a license under a third party's
+          intellectual property rights is required to exercise the rights
+          granted by such Contributor under Sections 2.1 or 2.2,
+          Contributor must include a text file with the Source Code
+          distribution titled "LEGAL" which describes the claim and the
+          party making the claim in sufficient detail that a recipient will
+          know whom to contact. If Contributor obtains such knowledge after
+          the Modification is made available as described in Section 3.2,
+          Contributor shall promptly modify the LEGAL file in all copies
+          Contributor makes available thereafter and shall take other steps
+          (such as notifying appropriate mailing lists or newsgroups)
+          reasonably calculated to inform those who received the Covered
+          Code that new knowledge has been obtained.
+
+          (b) Contributor APIs.
+          If Contributor's Modifications include an application programming
+          interface and Contributor has knowledge of patent licenses which
+          are reasonably necessary to implement that API, Contributor must
+          also include this information in the LEGAL file.
+
+               (c)    Representations.
+          Contributor represents that, except as disclosed pursuant to
+          Section 3.4(a) above, Contributor believes that Contributor's
+          Modifications are Contributor's original creation(s) and/or
+          Contributor has sufficient rights to grant the rights conveyed by
+          this License.
+
+     3.5. Required Notices.
+     You must duplicate the notice in Exhibit A in each file of the Source
+     Code.  If it is not possible to put such notice in a particular Source
+     Code file due to its structure, then You must include such notice in a
+     location (such as a relevant directory) where a user would be likely
+     to look for such a notice.  If You created one or more Modification(s)
+     You may add your name as a Contributor to the notice described in
+     Exhibit A.  You must also duplicate this License in any documentation
+     for the Source Code where You describe recipients' rights or ownership
+     rights relating to Covered Code.  You may choose to offer, and to
+     charge a fee for, warranty, support, indemnity or liability
+     obligations to one or more recipients of Covered Code. However, You
+     may do so only on Your own behalf, and not on behalf of the Initial
+     Developer or any Contributor. You must make it absolutely clear than
+     any such warranty, support, indemnity or liability obligation is
+     offered by You alone, and You hereby agree to indemnify the Initial
+     Developer and every Contributor for any liability incurred by the
+     Initial Developer or such Contributor as a result of warranty,
+     support, indemnity or liability terms You offer.
+
+     3.6. Distribution of Executable Versions.
+     You may distribute Covered Code in Executable form only if the
+     requirements of Section 3.1-3.5 have been met for that Covered Code,
+     and if You include a notice stating that the Source Code version of
+     the Covered Code is available under the terms of this License,
+     including a description of how and where You have fulfilled the
+     obligations of Section 3.2. The notice must be conspicuously included
+     in any notice in an Executable version, related documentation or
+     collateral in which You describe recipients' rights relating to the
+     Covered Code. You may distribute the Executable version of Covered
+     Code or ownership rights under a license of Your choice, which may
+     contain terms different from this License, provided that You are in
+     compliance with the terms of this License and that the license for the
+     Executable version does not attempt to limit or alter the recipient's
+     rights in the Source Code version from the rights set forth in this
+     License. If You distribute the Executable version under a different
+     license You must make it absolutely clear that any terms which differ
+     from this License are offered by You alone, not by the Initial
+     Developer or any Contributor. You hereby agree to indemnify the
+     Initial Developer and every Contributor for any liability incurred by
+     the Initial Developer or such Contributor as a result of any such
+     terms You offer.
+
+     3.7. Larger Works.
+     You may create a Larger Work by combining Covered Code with other code
+     not governed by the terms of this License and distribute the Larger
+     Work as a single product. In such a case, You must make sure the
+     requirements of this License are fulfilled for the Covered Code.
+
+   4. Inability to Comply Due to Statute or Regulation.
+
+     If it is impossible for You to comply with any of the terms of this
+     License with respect to some or all of the Covered Code due to
+     statute, judicial order, or regulation then You must: (a) comply with
+     the terms of this License to the maximum extent possible; and (b)
+     describe the limitations and the code they affect. Such description
+     must be included in the LEGAL file described in Section 3.4 and must
+     be included with all distributions of the Source Code. Except to the
+     extent prohibited by statute or regulation, such description must be
+     sufficiently detailed for a recipient of ordinary skill to be able to
+     understand it.
+
+   5. Application of this License.
+
+     This License applies to code to which the Initial Developer has
+     attached the notice in Exhibit A and to related Covered Code.
+
+   6. Versions of the License.
+
+     6.1. New Versions.
+     Netscape Communications Corporation ("Netscape") may publish revised
+     and/or new versions of the License from time to time. Each version
+     will be given a distinguishing version number.
+
+     6.2. Effect of New Versions.
+     Once Covered Code has been published under a particular version of the
+     License, You may always continue to use it under the terms of that
+     version. You may also choose to use such Covered Code under the terms
+     of any subsequent version of the License published by Netscape. No one
+     other than Netscape has the right to modify the terms applicable to
+     Covered Code created under this License.
+
+     6.3. Derivative Works.
+     If You create or use a modified version of this License (which you may
+     only do in order to apply it to code which is not already Covered Code
+     governed by this License), You must (a) rename Your license so that
+     the phrases "Mozilla", "MOZILLAPL", "MOZPL", "Netscape",
+     "MPL", "NPL" or any confusingly similar phrase do not appear in your
+     license (except to note that your license differs from this License)
+     and (b) otherwise make it clear that Your version of the license
+     contains terms which differ from the Mozilla Public License and
+     Netscape Public License. (Filling in the name of the Initial
+     Developer, Original Code or Contributor in the notice described in
+     Exhibit A shall not of themselves be deemed to be modifications of
+     this License.)
+
+   7. DISCLAIMER OF WARRANTY.
+
+     COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS,
+     WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+     WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF
+     DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING.
+     THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE
+     IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT,
+     YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE
+     COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER
+     OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF
+     ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
+
+   8. TERMINATION.
+
+     8.1.  This License and the rights granted hereunder will terminate
+     automatically if You fail to comply with terms herein and fail to cure
+     such breach within 30 days of becoming aware of the breach. All
+     sublicenses to the Covered Code which are properly granted shall
+     survive any termination of this License. Provisions which, by their
+     nature, must remain in effect beyond the termination of this License
+     shall survive.
+
+     8.2.  If You initiate litigation by asserting a patent infringement
+     claim (excluding declatory judgment actions) against Initial Developer
+     or a Contributor (the Initial Developer or Contributor against whom
+     You file such action is referred to as "Participant")  alleging that:
+
+     (a)  such Participant's Contributor Version directly or indirectly
+     infringes any patent, then any and all rights granted by such
+     Participant to You under Sections 2.1 and/or 2.2 of this License
+     shall, upon 60 days notice from Participant terminate prospectively,
+     unless if within 60 days after receipt of notice You either: (i)
+     agree in writing to pay Participant a mutually agreeable reasonable
+     royalty for Your past and future use of Modifications made by such
+     Participant, or (ii) withdraw Your litigation claim with respect to
+     the Contributor Version against such Participant.  If within 60 days
+     of notice, a reasonable royalty and payment arrangement are not
+     mutually agreed upon in writing by the parties or the litigation claim
+     is not withdrawn, the rights granted by Participant to You under
+     Sections 2.1 and/or 2.2 automatically terminate at the expiration of
+     the 60 day notice period specified above.
+
+     (b)  any software, hardware, or device, other than such Participant's
+     Contributor Version, directly or indirectly infringes any patent, then
+     any rights granted to You by such Participant under Sections 2.1(b)
+     and 2.2(b) are revoked effective as of the date You first made, used,
+     sold, distributed, or had made, Modifications made by that
+     Participant.
+
+     8.3.  If You assert a patent infringement claim against Participant
+     alleging that such Participant's Contributor Version directly or
+     indirectly infringes any patent where such claim is resolved (such as
+     by license or settlement) prior to the initiation of patent
+     infringement litigation, then the reasonable value of the licenses
+     granted by such Participant under Sections 2.1 or 2.2 shall be taken
+     into account in determining the amount or value of any payment or
+     license.
+
+     8.4.  In the event of termination under Sections 8.1 or 8.2 above,
+     all end user license agreements (excluding distributors and resellers)
+     which have been validly granted by You or any distributor hereunder
+     prior to termination shall survive termination.
+
+   9. LIMITATION OF LIABILITY.
+
+     UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT
+     (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL
+     DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE,
+     OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR
+     ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY
+     CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL,
+     WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER
+     COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN
+     INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF
+     LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY
+     RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW
+     PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE
+     EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO
+     THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.
+
+   10. U.S. GOVERNMENT END USERS.
+
+     The Covered Code is a "commercial item," as that term is defined in
+     48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer
+     software" and "commercial computer software documentation," as such
+     terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48
+     C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995),
+     all U.S. Government End Users acquire Covered Code with only those
+     rights set forth herein.
+
+   11. MISCELLANEOUS.
+
+     This License represents the complete agreement concerning subject
+     matter hereof. If any provision of this License is held to be
+     unenforceable, such provision shall be reformed only to the extent
+     necessary to make it enforceable. This License shall be governed by
+     California law provisions (except to the extent applicable law, if
+     any, provides otherwise), excluding its conflict-of-law provisions.
+     With respect to disputes in which at least one party is a citizen of,
+     or an entity chartered or registered to do business in the United
+     States of America, any litigation relating to this License shall be
+     subject to the jurisdiction of the Federal Courts of the Northern
+     District of California, with venue lying in Santa Clara County,
+     California, with the losing party responsible for costs, including
+     without limitation, court costs and reasonable attorneys' fees and
+     expenses. The application of the United Nations Convention on
+     Contracts for the International Sale of Goods is expressly excluded.
+     Any law or regulation which provides that the language of a contract
+     shall be construed against the drafter shall not apply to this
+     License.
+
+   12. RESPONSIBILITY FOR CLAIMS.
+
+     As between Initial Developer and the Contributors, each party is
+     responsible for claims and damages arising, directly or indirectly,
+     out of its utilization of rights under this License and You agree to
+     work with Initial Developer and Contributors to distribute such
+     responsibility on an equitable basis. Nothing herein is intended or
+     shall be deemed to constitute any admission of liability.
+
+   13. MULTIPLE-LICENSED CODE.
+
+     Initial Developer may designate portions of the Covered Code as
+     "Multiple-Licensed".  "Multiple-Licensed" means that the Initial
+     Developer permits you to utilize portions of the Covered Code under
+     Your choice of the NPL or the alternative licenses, if any, specified
+     by the Initial Developer in the file described in Exhibit A.
+
+   EXHIBIT A -Mozilla Public License.
+
+     ``The contents of this file are subject to the Mozilla Public License
+     Version 1.1 (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.mozilla.org/MPL/
+
+     Software distributed under the License is distributed on an "AS IS"
+     basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+     License for the specific language governing rights and limitations
+     under the License.
+
+     The Original Code is ______________________________________.
+
+     The Initial Developer of the Original Code is ________________________.
+     Portions created by ______________________ are Copyright (C) ______
+     _______________________. All Rights Reserved.
+
+     Contributor(s): ______________________________________.
+
+     Alternatively, the contents of this file may be used under the terms
+     of the _____ license (the  "[___] License"), in which case the
+     provisions of [______] License are applicable instead of those
+     above.  If you wish to allow use of your version of this file only
+     under the terms of the [____] License and not to allow others to use
+     your version of this file under the MPL, indicate your decision by
+     deleting  the provisions above and replace  them with the notice and
+     other provisions required by the [___] License.  If you do not delete
+     the provisions above, a recipient may use your version of this file
+     under either the MPL or the [___] License."
+
+     [NOTE: The text of this Exhibit A may differ slightly from the text of
+     the notices in the Source Code files of the Original Code. You should
+     use the text of this Exhibit A rather than the text found in the
+     Original Code Source Code for Your Modifications.]
diff --git a/src/main/resources/META-INF/NOTICE b/src/main/resources/META-INF/NOTICE
new file mode 100644
index 0000000..2604e73
--- /dev/null
+++ b/src/main/resources/META-INF/NOTICE
@@ -0,0 +1,11 @@
+Apache Sling JavaScript (Rhino) Scripting Support
+Copyright 2008 The Apache Software Foundation
+
+Apache Sling is based on source code originally developed 
+by Day Software (http://www.day.com/).
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
+
+This product includes software developed at
+mozilla.org (http://www.mozilla.org/).
diff --git a/src/main/resources/META-INF/services/javax.script.ScriptEngineFactory b/src/main/resources/META-INF/services/javax.script.ScriptEngineFactory
new file mode 100644
index 0000000..272fe50
--- /dev/null
+++ b/src/main/resources/META-INF/services/javax.script.ScriptEngineFactory
@@ -0,0 +1 @@
+org.apache.sling.scripting.javascript.RhinoJavaScriptEngineFactory
\ No newline at end of file
diff --git a/src/test/java/org/apache/sling/scripting/RepositoryScriptingTestBase.java b/src/test/java/org/apache/sling/scripting/RepositoryScriptingTestBase.java
new file mode 100644
index 0000000..bef52b3
--- /dev/null
+++ b/src/test/java/org/apache/sling/scripting/RepositoryScriptingTestBase.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting;
+
+import javax.jcr.Node;
+import javax.jcr.RepositoryException;
+import javax.naming.NamingException;
+
+import org.apache.sling.commons.testing.jcr.RepositoryTestBase;
+
+
+/** Base class for tests which need a Repository
+ *  and scripting functionality */
+public class RepositoryScriptingTestBase extends RepositoryTestBase {
+    protected ScriptEngineHelper script;
+    private int counter;
+    
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        script = new ScriptEngineHelper();
+    }
+    
+    protected Node getNewNode() throws RepositoryException, NamingException {
+        return getTestRootNode().addNode("test-" + (++counter));
+    }
+
+}
diff --git a/src/test/java/org/apache/sling/scripting/ScriptEngineHelper.java b/src/test/java/org/apache/sling/scripting/ScriptEngineHelper.java
new file mode 100644
index 0000000..fbdcda3
--- /dev/null
+++ b/src/test/java/org/apache/sling/scripting/ScriptEngineHelper.java
@@ -0,0 +1,99 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting;
+
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.script.Bindings;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptException;
+import javax.script.SimpleBindings;
+import javax.script.SimpleScriptContext;
+
+import org.apache.sling.scripting.javascript.RhinoJavaScriptEngineFactory;
+import org.mozilla.javascript.ScriptableObject;
+import org.mozilla.javascript.Wrapper;
+
+/** Helpers to run javascript code fragments in tests */
+public class ScriptEngineHelper {
+    private static ScriptEngine engine;
+
+    public static class Data extends HashMap<String, Object> {
+    }
+
+    private static ScriptEngine getEngine() {
+        if (engine == null) {
+            synchronized (ScriptEngineHelper.class) {
+                engine = new RhinoJavaScriptEngineFactory().getScriptEngine();
+            }
+        }
+        return engine;
+    }
+
+    public String evalToString(String javascriptCode) throws ScriptException {
+        return evalToString(javascriptCode, null);
+    }
+
+    public Object eval(String javascriptCode, Map<String, Object> data)
+            throws ScriptException {
+        return eval(javascriptCode, data, new StringWriter());
+    }
+
+    public String evalToString(String javascriptCode, Map<String, Object> data)
+            throws ScriptException {
+        final StringWriter sw = new StringWriter();
+        eval(javascriptCode, data, sw);
+        return sw.toString();
+    }
+
+    public Object eval(String javascriptCode, Map<String, Object> data,
+            final StringWriter sw) throws ScriptException {
+        final PrintWriter pw = new PrintWriter(sw, true);
+        ScriptContext ctx = new SimpleScriptContext();
+
+        final Bindings b = new SimpleBindings();
+        b.put("out", pw);
+        if (data != null) {
+            for (Map.Entry<String, Object> e : data.entrySet()) {
+                b.put(e.getKey(), e.getValue());
+            }
+        }
+
+        ctx.setBindings(b, ScriptContext.ENGINE_SCOPE);
+        ctx.setWriter(sw);
+        ctx.setErrorWriter(new OutputStreamWriter(System.err));
+        Object result = getEngine().eval(javascriptCode, ctx);
+        
+        if (result instanceof Wrapper) {
+            result = ((Wrapper) result).unwrap();
+        }
+        
+        if (result instanceof ScriptableObject) {
+            result = ((ScriptableObject) result).getDefaultValue(null);
+        }
+
+        return result;
+    }
+
+}
diff --git a/src/test/java/org/apache/sling/scripting/TestSetupTest.java b/src/test/java/org/apache/sling/scripting/TestSetupTest.java
new file mode 100644
index 0000000..c920141
--- /dev/null
+++ b/src/test/java/org/apache/sling/scripting/TestSetupTest.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting;
+
+
+/** Verify that our test environment works */
+public class TestSetupTest extends RepositoryScriptingTestBase {
+    
+    /** Test our test repository setup */
+    public void testRootNode() throws Exception {
+        assertNotNull(getTestRootNode());
+    }
+    
+    /** Test our script engine setup */
+    public void testScripting() throws Exception {
+        assertEquals("something",script.evalToString("out.print('something')"));
+    }
+    
+    public void testScriptingWithData() throws Exception {
+        final ScriptEngineHelper.Data data = new ScriptEngineHelper.Data();
+        data.put("a", "A");
+        data.put("b", "B");
+        assertEquals("A1",script.evalToString("out.print(a + b.length)", data));
+    }
+}
diff --git a/src/test/java/org/apache/sling/scripting/javascript/io/EspReaderTest.java b/src/test/java/org/apache/sling/scripting/javascript/io/EspReaderTest.java
new file mode 100644
index 0000000..9bc8f2b
--- /dev/null
+++ b/src/test/java/org/apache/sling/scripting/javascript/io/EspReaderTest.java
@@ -0,0 +1,300 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.javascript.io;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringReader;
+
+import javax.script.ScriptException;
+
+import junit.framework.TestCase;
+
+import org.apache.sling.scripting.ScriptEngineHelper;
+
+/**
+ * The <code>EspReaderTest</code> contains some simple test cases for the
+ * <code>EspReader</code> class which processes ESP (ECMA Server Page) templated
+ * JavaScript and produces plain JavaScript.
+ */
+public class EspReaderTest extends TestCase {
+
+    /** Test read() method */
+    public void testReadSingle() throws IOException {
+        String src = "<%var%>"; // expect var on reader
+
+        Reader reader = new EspReader(new StringReader(src));
+
+        assertTrue("Character 1 must be 'v'", 'v' == reader.read());
+        assertTrue("Character 2 must be 'a'", 'a' == reader.read());
+        assertTrue("Character 3 must be 'r'", 'r' == reader.read());
+        assertTrue("Character 4 must be -1", -1 == reader.read());
+    }
+
+    /** Test read(char[], int, int) method */
+    public void testReadArrayAll() throws IOException {
+        String src = "<%var%>"; // expect var on reader
+
+        Reader reader = new EspReader(new StringReader(src));
+        char[] buf = new char[3];
+        int rd = reader.read(buf, 0, buf.length);
+
+        assertEquals(3, rd);
+        assertEquals("var", new String(buf, 0, rd));
+
+        // nothing more to read, expect EOF
+        rd = reader.read(buf, 0, buf.length);
+        assertEquals(-1, rd);
+    }
+
+    /** Test read(char[], int, int) method */
+    public void testReadArrayOffset() throws IOException {
+        String jsSrc = "var x = 0;";
+        String src = "<%" + jsSrc + "%>";
+
+        Reader reader = new EspReader(new StringReader(src));
+        char[] buf = new char[10];
+        int off = 2;
+        int len = 3;
+        int rd = reader.read(buf, off, len);
+        assertEquals(len, rd);
+        assertEquals("var", new String(buf, off, rd));
+
+        off = 2;
+        len = 7;
+        rd = reader.read(buf, off, len);
+        assertEquals(len, rd);
+        assertEquals(" x = 0;", new String(buf, off, rd));
+
+        // nothing more to read, expect EOF
+        rd = reader.read(buf, 0, buf.length);
+        assertEquals(-1, rd);
+    }
+
+    /** Test standard template text */
+    public void testTemplate() throws IOException {
+        assertEquals("out=response.writer;out.write(\"test\");", parse("test"));
+        assertEquals("out=response.writer;out.write(\"test\\n\");\nout.write(\"test2\");", parse("test\ntest2"));
+    }
+    
+    /** Test with a custom "out" initialization */
+    public void testOutInit() throws IOException {
+        final String input = "test";
+        final String expected = "out=getOut();out.write(\"test\");";
+            
+        StringBuffer buf = new StringBuffer();
+
+        EspReader r = new EspReader(new StringReader(input));
+        r.setOutInitStatement("out=getOut();");
+        int c;
+        while ( (c=r.read()) >= 0) {
+            buf.append( (char) c);
+        }
+
+        assertEquals(expected, buf.toString());
+    }
+
+    /** Test plain JavaScript code */
+    public void testCode() throws IOException {
+        assertEquals(" test(); ", parse("<% test(); %>"));
+        assertEquals(" \ntest();\ntest2(); ", parse("<% \ntest();\ntest2(); %>"));
+    }
+
+    /** Test JavaScript expressions */
+    public void testExpr() throws IOException {
+        assertEquals("out=response.writer;out.write( x + 1 );", parse("<%= x + 1 %>"));
+        assertEquals("out=response.writer;out.write(\"<!-- \");out.write( x + 1 );out.write(\" -->\");", parse("<!-- <%= x + 1 %> -->"));
+    }
+
+    /** Test JavaScript comment */
+    public void testComment() throws IOException {
+        assertEquals("", parse("<%-- test(); --%>"));
+    }
+    
+    public void testCompactExpressionsDouble() throws IOException {
+    	final String input = "<html version=\"${1+1}\">\n";
+    	final String expected = "out=response.writer;out.write(\"<html version=\\\"\");out.write(1+1);out.write(\"\\\">\\n\");\n";
+    	final String actual = parse(input);
+        assertEquals(flatten(expected), flatten(actual));
+    }
+    
+    public void testCompactExpressionsDoubleNegative() throws IOException {
+    	final String input = "<html version=\"{1+1}\">\n";
+    	final String expected = "out=response.writer;out.write(\"<html version=\\\"{1+1}\\\">\\n\");\n";
+    	final String actual = parse(input);
+        assertEquals(flatten(expected), flatten(actual));
+    }
+    
+    public void testCompactExpressionsSingle() throws IOException {
+    	final String input = "<html version='${1+1}'>\n";
+    	final String expected = "out=response.writer;out.write(\"<html version='\");out.write(1+1);out.write(\"'>\\n\");\n";
+    	final String actual = parse(input);
+        assertEquals(flatten(expected), flatten(actual));
+    }
+    
+    public void testCompactExpressionsSingleNegative() throws IOException {
+    	final String input = "<html version='{1+1}'>\n";
+    	final String expected = "out=response.writer;out.write(\"<html version='{1+1}'>\\n\");\n";
+    	final String actual = parse(input);
+        assertEquals(flatten(expected), flatten(actual));
+    }
+    
+    /** Test a complete template, using all features */
+    public void testCompleteTemplate() throws IOException {
+        final String input =
+            "<html>\n"
+            + "<head><title><%= someExpr %></title></head>\n"
+            + "<!-- some HTML comment -->\n"
+            + "<-- some ESP comment -->\n"
+            + "// some javascript comment\n"
+            + "/* another javascript comment /*\n"
+            + "<%\n"
+            + "expr on\n"
+            + "two lines\n"
+            + "%>\n"
+            + "<verbatim stuff=\"quoted\">xyz</verbatim>\n"
+            + "<moreverbatim stuff=\'single\'>xx</moreverbatim>\n"
+            + "<!-- HTML comment with <% expr.here; %> and EOL\n-->\n"
+            + "</html>"
+        ;
+        
+        final String expected = 
+            "out=response.writer;out.write(\"<html>\\n\");\n"
+            + "out.write(\"<head><title>\");out.write( someExpr );out.write(\"</title></head>\\n\");\n"
+            + "out.write(\"<!-- some HTML comment -->\\n\");\n"
+            + "out.write(\"<-- some ESP comment -->\\n\");\n"
+            + "out.write(\"// some javascript comment\\n\");\n"
+            + "out.write(\"/* another javascript comment /*\\n\");\n"
+            + "\n"
+            + "expr on\n"
+            + "two lines\n"
+            + "out.write(\"\\n\");\n"
+            + "out.write(\"<verbatim stuff=\\\"quoted\\\">xyz</verbatim>\\n\");\n"
+            + "out.write(\"<moreverbatim stuff='single'>xx</moreverbatim>\\n\");\n"
+            + "out.write(\"<!-- HTML comment with \"); expr.here; out.write(\" and EOL\\n\");\n"
+            + "out.write(\"-->\\n\");\n"
+            + "out.write(\"</html>\");"
+        ;
+        
+        final String actual = parse(input);
+        assertEquals(flatten(expected), flatten(actual));
+    }
+
+    /** Test a complete template, using all features */
+    public void testNumericExpression() throws IOException {
+        String input = "<%= 1 %>";
+        String expected = "out=response.writer;out.write( 1 );";
+        String actual = parse(input);
+        assertEquals(expected, actual);
+        
+        input = "<%= \"1\" %>";
+        expected = "out=response.writer;out.write( \"1\" );";
+        actual = parse(input);
+        assertEquals(expected, actual);
+        
+        input = "<%= '1' %>";
+        expected = "out=response.writer;out.write( '1' );";
+        actual = parse(input);
+        assertEquals(expected, actual);
+    }
+    
+    /** Test a complete template, using all features */
+    public void testNumericExpressionOutput() throws ScriptException {
+        ScriptEngineHelper script = new ScriptEngineHelper();
+        
+        String input = "out.write( 1 );";
+        String actual = script.evalToString(input);
+        String expected = "1";
+        assertEquals(expected, actual);
+
+        input = "out.write( \"1\" );";
+        actual = script.evalToString(input);
+        expected = "1";
+        assertEquals(expected, actual);
+
+        input = "out.write( '1' );";
+        actual = script.evalToString(input);
+        expected = "1";
+        assertEquals(expected, actual);
+    }
+    
+    public void testColon() throws IOException {
+        final String input = "currentNode.text:<%= currentNode.text %>";
+        final String expected = 
+            "out=response.writer;" 
+            + "out.write(\"currentNode.text:\");"
+            + "out.write( currentNode.text );"
+            ;
+        final String actual = parse(input);
+        assertEquals(expected, actual);
+    }
+    
+    public void testEqualSigns() throws IOException {
+        final String input = "currentNode.text=<%= currentNode.text %>";
+        final String expected = 
+            "out=response.writer;" 
+            + "out.write(\"currentNode.text=\");"
+            + "out.write( currentNode.text );"
+            ;
+        final String actual = parse(input);
+        assertEquals(expected, actual);
+    }
+    
+    public void testSingleQuoted() throws IOException {
+        final String input = "currentNode.text='<%= currentNode.text %>'";
+        final String expected = 
+            "out=response.writer;" 
+            + "out.write(\"currentNode.text='\");"
+            + "out.write( currentNode.text );"
+            + "out.write(\"'\");"
+            ;
+        final String actual = parse(input);
+        assertEquals(expected, actual);
+    }
+    
+    public void testDoubleQuoted() throws IOException {
+        final String input = "currentNode.text=\"<%= currentNode.text %>\"";
+        final String expected = 
+            "out=response.writer;" 
+            + "out.write(\"currentNode.text=\\\"\");"
+            + "out.write( currentNode.text );"
+            + "out.write(\"\\\"\");"
+            ;
+        final String actual = parse(input);
+        assertEquals(expected, actual);
+    }
+    
+    /** Helper to pass an ESP text through the EspReader and return the result */
+    private String parse(String text) throws IOException {
+        StringBuffer buf = new StringBuffer();
+
+        Reader r = new EspReader(new StringReader(text));
+        int c;
+        while ( (c=r.read()) >= 0) {
+            buf.append( (char) c);
+        }
+
+        return buf.toString();
+    }
+    
+    /** Replace \n with . in strings to make it easier to compare visually for testing */
+    private static String flatten(String str) {
+        return str.replace('\n', '.');
+    }
+}
diff --git a/src/test/java/org/apache/sling/scripting/wrapper/ScriptableNodeTest.java b/src/test/java/org/apache/sling/scripting/wrapper/ScriptableNodeTest.java
new file mode 100644
index 0000000..bde9611
--- /dev/null
+++ b/src/test/java/org/apache/sling/scripting/wrapper/ScriptableNodeTest.java
@@ -0,0 +1,337 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.wrapper;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+
+import javax.jcr.Node;
+import javax.jcr.Property;
+
+import org.apache.sling.scripting.RepositoryScriptingTestBase;
+import org.apache.sling.scripting.ScriptEngineHelper;
+import org.apache.sling.commons.json.jcr.JsonItemWriter;
+
+/** Test the ScriptableNode class "live", by retrieving
+ *  Nodes from a Repository and executing javascript code
+ *  using them.
+ */
+public class ScriptableNodeTest extends RepositoryScriptingTestBase {
+
+    private Node node;
+    private Property textProperty;
+    private String testText;
+    private Property numProperty;
+    private double testNum;
+    private Property calProperty;
+    private Calendar testCal;
+    private ScriptEngineHelper.Data data;
+    
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        
+        node = getNewNode();
+        testText = "Test-" + System.currentTimeMillis();
+        node.setProperty("text", testText);
+        node.setProperty("otherProperty", node.getPath());
+        
+        testNum = System.currentTimeMillis();
+        node.setProperty("num", testNum);
+        
+        testCal = Calendar.getInstance();
+        node.setProperty("cal", testCal);
+        
+        data = new ScriptEngineHelper.Data();
+        data.put("node", node);
+        textProperty = node.getProperty("text");
+        data.put("property", textProperty);
+        numProperty = node.getProperty("num");
+        data.put("numProperty", numProperty);
+        calProperty = node.getProperty("cal");
+        data.put("calProperty", calProperty);
+    }
+
+    public void testDefaultValue() throws Exception {
+        final ScriptEngineHelper.Data data = new ScriptEngineHelper.Data();
+        data.put("node", getTestRootNode());
+        assertEquals(
+                getTestRootNode().getPath(),
+                script.evalToString("out.print(node)", data)
+        );
+    }
+
+    public void testPrimaryNodeType() throws Exception {
+        final ScriptEngineHelper.Data data = new ScriptEngineHelper.Data();
+        data.put("node", getTestRootNode());
+        assertEquals(
+                "nt:unstructured",
+                script.evalToString("out.print(node.getPrimaryNodeType().getName())", data)
+        );
+    }
+
+    public void testPrimaryNodeTypeProperty() throws Exception {
+        final ScriptEngineHelper.Data data = new ScriptEngineHelper.Data();
+        data.put("node", getTestRootNode());
+        assertEquals(
+                "nt:unstructured",
+                script.evalToString("out.print(node['jcr:primaryType'])", data)
+        );
+    }
+
+    public void testViaPropertyNoWrappers() throws Exception {
+        assertEquals(
+            testText,
+            script.evalToString("out.print(property.value.string)", data)
+        );
+    }
+    
+    public void testViaPropertyWithWrappers() throws Exception {
+        assertEquals(
+            textProperty.getString(),
+            script.evalToString("out.print(property)", data)
+        );
+    }
+    
+    public void testViaNodeDirectPropertyAccess() throws Exception {
+        assertEquals(
+            testText,
+            script.evalToString("out.print(node.text)", data)
+        );
+    }
+    
+    public void testViaPropertyNoWrappersNum() throws Exception {
+        assertEquals(
+            testNum,
+            script.eval("numProperty.value.getDouble()", data)
+        );
+    }
+    
+    public void testViaPropertyWithWrappersNum() throws Exception {
+        assertEquals(
+            testNum,
+            script.eval("0+numProperty", data)
+        );
+    }
+    
+    public void testViaNodeDirectPropertyAccessNum() throws Exception {
+        assertEquals(
+            testNum,
+            script.eval("node.num", data)
+        );
+    }
+    
+    public void testViaPropertyNoWrappersCal() throws Exception {
+        assertEquals(
+                testCal,
+                script.eval("calProperty.value.getDate()", data)
+        );
+    }
+    
+    public void testDateWrapperClass() throws Exception {
+        assertEquals(
+                "org.apache.sling.scripting.javascript.wrapper.ScriptableCalendar", 
+                script.eval("node.cal.javascriptWrapperClass.getName()", data)
+        );
+    }
+    
+    public void testViaNodeDirectPropertyAccessCal() throws Exception {
+    	final SimpleDateFormat f = new SimpleDateFormat(JsonItemWriter.ECMA_DATE_FORMAT, JsonItemWriter.DATE_FORMAT_LOCALE);
+    	final String expected = f.format(testCal.getTime());
+        assertEquals(
+                expected,
+                script.evalToString("out.print(node.cal)", data)
+        );
+    }
+    
+    public void testCalDateClass() throws Exception {
+        assertEquals(
+                "number",
+                script.evalToString("out.print(typeof node.cal.date.time)", data)
+        );
+    }
+    
+    public void testPropertyParent() throws Exception {
+        // need to use node.getProperty('num') to have a ScriptableProperty,
+        // node.num only returns a wrapped value
+        assertEquals(
+                "nt:unstructured",
+                script.eval("node.getProperty('num').parent['jcr:primaryType']", data)
+        );
+    }
+    
+    public void testPropertyWrapperClass() throws Exception {
+        assertEquals(
+                "org.apache.sling.scripting.javascript.wrapper.ScriptableProperty", 
+                script.eval("node.getProperty('num').javascriptWrapperClass.getName()", data)
+        );
+    }
+    
+    public void testPropertyAncestor() throws Exception {
+        // call getAncestor which is not explicitly defined in ScriptableProperty,
+        // to verify that all Property methods are available and that we get a 
+        // correctly wrapped result (SLING-397)
+        assertEquals(
+                "rep:root",
+                script.eval("node.getProperty('num').getAncestor(0)['jcr:primaryType']", data)
+        );
+    }
+    
+    public void testPropertiesIterationNoWrapper() throws Exception {
+        final String code = 
+            "var props = node.getProperties();"
+            + " for(i in props) { out.print(props[i].name); out.print(' '); }"
+        ;
+        final String result = script.evalToString(code, data);
+        final String [] names = { "text", "otherProperty" };
+        for(String name : names) {
+            assertTrue("result (" + result + ") contains '" + name + "'", result.contains(name));
+        }
+    }
+    
+    public void testAddNodeDefaultType() throws Exception {
+        final String path = "subdt_" + System.currentTimeMillis();
+        final String code =
+            "var n = node.addNode('" + path + "');\n"
+            + "out.print(n['jcr:primaryType']);\n"
+        ;
+        assertEquals("nt:unstructured", script.evalToString(code, data));
+    }
+    
+    public void testAddNodeSpecificType() throws Exception {
+        final String path = "subst_" + System.currentTimeMillis();
+        final String code =
+            "var n = node.addNode('" + path + "', 'nt:folder');\n"
+            + "out.print(n['jcr:primaryType']);\n"
+        ;
+        assertEquals("nt:folder", script.evalToString(code, data));
+    }
+    
+    public void testGetNode() throws Exception {
+        final String path = "subgn_" + System.currentTimeMillis();
+        final String code =
+            "node.addNode('" + path + "', 'nt:resource');\n"
+            + "var n=node.getNode('" + path + "');\n"
+            + "out.print(n['jcr:primaryType']);\n"
+        ;
+        assertEquals("nt:resource", script.evalToString(code, data));
+    }
+
+    public void testGetProperty() throws Exception {
+        final String code = "out.print(node.getProperty('text'));";
+        assertEquals(testText, script.evalToString(code, data));
+    }
+    
+    public void testGetNodesNoPattern() throws Exception {
+        final String path = "subgnnp_" + System.currentTimeMillis();
+        final String code =
+            "node.addNode('" + path + "_A');\n"
+            + "node.addNode('" + path + "_B');\n"
+            + "var nodes = node.getNodes();\n"
+            + "for (i in nodes) { out.print(nodes[i].getName() + ' '); }\n"
+        ;
+        assertEquals(path + "_A " + path + "_B ", script.evalToString(code, data));
+    }
+    
+    public void testGetNodesWithPattern() throws Exception {
+        final String path = "subgnnp_" + System.currentTimeMillis();
+        final String code =
+            "node.addNode('1_" + path + "_A');\n"
+            + "node.addNode('1_" + path + "_B');\n"
+            + "node.addNode('2_" + path + "_C');\n"
+            + "var nodes = node.getNodes('1_*');\n"
+            + "for (i in nodes) { out.print(nodes[i].getName() + ' '); }\n"
+        ;
+        assertEquals("1_" + path + "_A 1_" + path + "_B ", script.evalToString(code, data));
+    }
+    
+    public void testRemoveNode() throws Exception {
+        final String code =
+            "node.addNode('toremove');\n"
+            + "out.print(node.hasNode('toremove'))\n"
+            + "out.print(' ')\n"
+            + "node.getNode('toremove').remove()\n"
+            + "out.print(node.hasNode('toremove'))\n"
+        ;
+        assertEquals("true false", script.evalToString(code, data));
+    }
+    
+    /** Test SLING-389 */
+    public void testForCurrentNode() throws Exception {
+        final String code = "for (var a in node) {}; out.print('ok')";
+        assertEquals("ok", script.evalToString(code, data));
+    }
+    
+    public void testChildNodeAccess() throws Exception {
+        final String path = "subtcna_" + System.currentTimeMillis();
+        final String code =
+            "node.addNode('" + path + "');\n"
+            + "var n=node.getNode('" + path + "');\n"
+            + "out.print(n['jcr:primaryType']);\n"
+            + "out.print(' ');\n"
+            + "var n2=node['" + path + "'];\n"
+            + "out.print(n2['jcr:primaryType']);\n"
+        ;
+        assertEquals("nt:unstructured nt:unstructured", script.evalToString(code, data));
+    }
+    
+    /** Verify that the getAncestor() method (which is not explicitely defined in ScriptableNode)
+     *  is available, to check SLING-397.
+     */
+    public void testGetAncestor() throws Exception {
+        {
+            final String code = "out.print(node.getAncestor(0).getPath());";
+            assertEquals("/", script.evalToString(code, data));
+        }
+        
+        {
+            final String code = "out.print(node.getAncestor(0)['jcr:primaryType']);";
+            assertEquals("rep:root", script.evalToString(code, data));
+        }
+    }
+    
+    public void testIsNodeType() throws Exception {
+        final String code = 
+            "out.print(node.isNodeType('nt:unstructured'));\n"
+            + "out.print(' ');\n"
+            + "out.print(node.isNodeType('nt:file'));"
+        ;
+        assertEquals("true false", script.evalToString(code, data));
+    }
+    
+    public void testNodeWrapperClass() throws Exception {
+        assertEquals(
+                "org.apache.sling.scripting.javascript.wrapper.ScriptableNode", 
+                script.eval("node.javascriptWrapperClass.getName()", data)
+        );
+    }
+    
+    public void testGetSession() throws Exception {
+        assertEquals(
+                "Root node found via node.session",
+                "/", 
+                script.eval("node.session.getRootNode().getPath()", data)
+        );
+        assertEquals(
+                "Root node found via node.getSession()",
+                "/", 
+                script.eval("node.getSession().getRootNode().getPath()", data)
+        );
+    }
+}
diff --git a/src/test/java/org/apache/sling/scripting/wrapper/ScriptableResourceTest.java b/src/test/java/org/apache/sling/scripting/wrapper/ScriptableResourceTest.java
new file mode 100644
index 0000000..6c7ed57
--- /dev/null
+++ b/src/test/java/org/apache/sling/scripting/wrapper/ScriptableResourceTest.java
@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.wrapper;
+
+import javax.jcr.Item;
+import javax.jcr.Node;
+import javax.jcr.RepositoryException;
+
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceMetadata;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.apache.sling.scripting.RepositoryScriptingTestBase;
+import org.apache.sling.scripting.ScriptEngineHelper;
+import org.mozilla.javascript.Undefined;
+import org.mozilla.javascript.Wrapper;
+
+public class ScriptableResourceTest extends RepositoryScriptingTestBase {
+
+    private Node node;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        node = getNewNode();
+    }
+
+    public void testDefaultValuePath() throws Exception {
+        final ScriptEngineHelper.Data data = new ScriptEngineHelper.Data();
+        data.put("resource", new TestResource(node));
+
+        // the path of the resource
+        assertEquals(node.getPath(), script.evalToString("out.print(resource)",
+            data));
+        assertEquals(node.getPath(), script.eval("resource.path", data));
+        assertEquals(node.getPath(), script.eval("resource.getPath()", data));
+    }
+
+    public void testAdaptToNode() throws Exception {
+        final ScriptEngineHelper.Data data = new ScriptEngineHelper.Data();
+        data.put("resource", new TestResource(node));
+
+        // the node to which the resource adapts
+        assertEquals(node, script.eval("resource.adaptTo('javax.jcr.Node')",
+            data));
+        assertEquals(node, script.eval(
+            "resource.adaptTo(Packages.javax.jcr.Node)", data));
+    }
+
+    public void testAdaptToNothing() throws Exception {
+        final ScriptEngineHelper.Data data = new ScriptEngineHelper.Data();
+        data.put("resource", new TestResource(node));
+
+        // the node to which the resource adapts
+        assertEquals(Undefined.instance,
+            script.eval("resource.adaptTo()", data));
+        assertEquals(Undefined.instance, script.eval("resource.adaptTo(null)",
+            data));
+        assertEquals(Undefined.instance, script.eval(
+            "resource.adaptTo(undefined)", data));
+        assertEquals(Undefined.instance, script.eval(
+            "resource.adaptTo(Packages.java.util.Date)", data));
+    }
+    
+    public void testResourceWrapperClass() throws Exception {
+        final ScriptEngineHelper.Data data = new ScriptEngineHelper.Data();
+        data.put("resource", new TestResource(node));
+        
+        assertEquals(
+                "org.apache.sling.scripting.javascript.wrapper.ScriptableResource", 
+                script.eval("resource.javascriptWrapperClass.getName()", data)
+        );
+    }
+
+    private void assertEquals(Node expected, Object actual) {
+        while (actual instanceof Wrapper) {
+            actual = ((Wrapper) actual).unwrap();
+        }
+
+        super.assertEquals(expected, actual);
+    }
+
+    private static class TestResource implements Resource {
+
+        private final Node node;
+
+        private final String path;
+
+        private final String resourceType;
+
+        private final ResourceMetadata metadata;
+
+        TestResource(Node node) throws RepositoryException {
+            this.node = node;
+            this.path = node.getPath();
+            this.resourceType = node.getPrimaryNodeType().getName();
+            this.metadata = new ResourceMetadata();
+            this.metadata.setResolutionPath(this.path);
+        }
+
+        public String getPath() {
+            return path;
+        }
+
+        public ResourceMetadata getResourceMetadata() {
+            return metadata;
+        }
+
+        public ResourceResolver getResourceResolver() {
+            // none, don't care
+            return null;
+        }
+
+        public String getResourceType() {
+            return resourceType;
+        }
+
+        public String getResourceSuperType() {
+            return null;
+        }
+
+        @SuppressWarnings("unchecked")
+        public <AdapterType> AdapterType adaptTo(Class<AdapterType> type) {
+            if (type == Node.class || type == Item.class) {
+                return (AdapterType) node;
+            }
+
+            return null;
+        }
+
+    }
+
+}
diff --git a/src/test/java/org/apache/sling/scripting/wrapper/ScriptableVersionTest.java b/src/test/java/org/apache/sling/scripting/wrapper/ScriptableVersionTest.java
new file mode 100644
index 0000000..336f3d7
--- /dev/null
+++ b/src/test/java/org/apache/sling/scripting/wrapper/ScriptableVersionTest.java
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.sling.scripting.wrapper;
+
+import javax.jcr.Node;
+
+import org.apache.sling.scripting.RepositoryScriptingTestBase;
+import org.apache.sling.scripting.ScriptEngineHelper;
+
+/** Test access to Version and VersionHistory objects */
+public class ScriptableVersionTest extends RepositoryScriptingTestBase {
+
+    private Node node;
+    private ScriptEngineHelper.Data data = new ScriptEngineHelper.Data();
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        node = getNewNode();
+        data.put("node", node);
+        node.addMixin("mix:versionable");
+        getSession().save();
+
+        node.setProperty("Modified", "Just making sure we have a second version");
+        getSession().save();
+    }
+
+    public void testVersionHistoryAccess() throws Exception {
+        Object result = script.eval("node.getVersionHistory().getAllVersions()", data);
+        assertNotNull(result);
+    }
+
+    public void testVersionHistoryIsWrapped() throws Exception {
+        assertEquals("nt:versionHistory", script.eval("node.versionHistory['jcr:primaryType']", data));
+        assertEquals("nt:version", script.eval("node.versionHistory.rootVersion['jcr:primaryType']", data));
+    }
+
+    public void testVersionHistoryWrapperClass() throws Exception {
+        assertEquals(
+                "org.apache.sling.scripting.javascript.wrapper.ScriptableVersionHistory", 
+                script.eval("node.versionHistory.javascriptWrapperClass.getName()", data)
+        );
+    }
+
+    public void testVersionAccess() throws Exception {
+        Object result = script.eval("node.getBaseVersion().getCreated()", data);
+        assertNotNull(result);
+    }
+
+    public void testVersionIsWrapped() throws Exception {
+        assertEquals("nt:version", script.eval("node.baseVersion['jcr:primaryType']", data));
+        assertNotNull(script.eval("node.baseVersion.created", data));
+    }
+    
+    public void testVersionWrapperClass() throws Exception {
+        assertEquals(
+                "org.apache.sling.scripting.javascript.wrapper.ScriptableVersion", 
+                script.eval("node.baseVersion.javascriptWrapperClass.getName()", data)
+        );
+    }
+}
diff --git a/src/test/test-config/jackrabbit-test-config.xml b/src/test/test-config/jackrabbit-test-config.xml
new file mode 100644
index 0000000..c1a408c
--- /dev/null
+++ b/src/test/test-config/jackrabbit-test-config.xml
@@ -0,0 +1,117 @@
+<?xml version="1.0"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.
+-->
+<!DOCTYPE Repository PUBLIC "-//The Apache Software Foundation//DTD Jackrabbit 1.2//EN"
+                            "http://jackrabbit.apache.org/dtd/repository-1.2.dtd">
+<Repository>
+    <!--
+        virtual file system where the repository stores global state
+        (e.g. registered namespaces, custom node types, etc.)
+    -->
+    <FileSystem class="org.apache.jackrabbit.core.fs.local.LocalFileSystem">
+        <param name="path" value="${rep.home}/repository"/>
+    </FileSystem>
+
+    <!--
+        security configuration
+    -->
+    <Security appName="Jackrabbit">
+        <!--
+            access manager:
+            class: FQN of class implementing the AccessManager interface
+        -->
+        <AccessManager class="org.apache.jackrabbit.core.security.SimpleAccessManager">
+            <!-- <param name="config" value="${rep.home}/access.xml"/> -->
+        </AccessManager>
+
+        <LoginModule class="org.apache.jackrabbit.core.security.SimpleLoginModule">
+           <!-- anonymous user name ('anonymous' is the default value) -->
+           <param name="anonymousId" value="anonymous"/>
+           <!--
+              default user name to be used instead of the anonymous user
+              when no login credentials are provided (unset by default)
+           -->
+           <param name="defaultUserId" value="superuser"/>
+        </LoginModule>
+    </Security>
+
+    <!--
+        location of workspaces root directory and name of default workspace
+    -->
+    <Workspaces rootPath="${rep.home}/workspaces" defaultWorkspace="default"/>
+    <!--
+        workspace configuration template:
+        used to create the initial workspace if there's no workspace yet
+    -->
+    <Workspace name="Jackrabbit Core">
+        <!--
+            virtual file system of the workspace:
+            class: FQN of class implementing the FileSystem interface
+        -->
+        <FileSystem class="org.apache.jackrabbit.core.fs.local.LocalFileSystem">
+            <param name="path" value="${wsp.home}"/>
+        </FileSystem>
+        <!--
+            persistence manager of the workspace:
+            class: FQN of class implementing the PersistenceManager interface
+        -->
+        <PersistenceManager class="org.apache.jackrabbit.core.persistence.db.DerbyPersistenceManager">
+          <param name="url" value="jdbc:derby:${wsp.home}/db;create=true"/>
+          <param name="schemaObjectPrefix" value="Jackrabbit Core_"/>
+        </PersistenceManager>
+        <!--
+            Search index and the file system it uses.
+            class: FQN of class implementing the QueryHandler interface
+        -->
+        <SearchIndex class="org.apache.jackrabbit.core.query.lucene.SearchIndex">
+            <param name="path" value="${wsp.home}/index"/>
+        </SearchIndex>
+    </Workspace>
+
+    <!--
+        Configures the versioning
+    -->
+    <Versioning rootPath="${rep.home}/version">
+        <!--
+            Configures the filesystem to use for versioning for the respective
+            persistence manager
+        -->
+        <FileSystem class="org.apache.jackrabbit.core.fs.local.LocalFileSystem">
+            <param name="path" value="${rep.home}/version" />
+        </FileSystem>
+
+        <!--
+            Configures the persistence manager to be used for persisting version state.
+            Please note that the current versioning implementation is based on
+            a 'normal' persistence manager, but this could change in future
+            implementations.
+        -->
+        <PersistenceManager class="org.apache.jackrabbit.core.persistence.db.DerbyPersistenceManager">
+          <param name="url" value="jdbc:derby:${rep.home}/version/db;create=true"/>
+          <param name="schemaObjectPrefix" value="version_"/>
+        </PersistenceManager>
+    </Versioning>
+
+    <!--
+        Search index for content that is shared repository wide
+        (/jcr:system tree, contains mainly versions)
+    -->
+    <SearchIndex class="org.apache.jackrabbit.core.query.lucene.SearchIndex">
+        <param name="path" value="${rep.home}/repository/index"/>
+    </SearchIndex>
+</Repository>
+