diff --git a/.travis.yml b/.travis.yml
index 6491036..63c844d 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,4 @@
 language: node_js
 node_js:
-  - "4.2"
-  - "0.12"
-  - "0.10"
+  - "lts/*"
 sudo: false
diff --git a/README.md b/README.md
index 1e178cb..fdf0ed5 100644
--- a/README.md
+++ b/README.md
@@ -1,76 +1,138 @@
-## JSURL
+# JSURL
+
+JSURL aims to be a drop-in replacement for JSON encoding with better size and time characteristics.
+
+JSURL has been designed to be
+
+- Fast: our test case actually outperforms native JSON
+- Compact: shorter output than JSON
+- Readable: it leaves accented characters unchanged and doesn't add much characters for encoding
+- URI-ready: It does not encode everything that should be URI-encoded, but it does encode all delimiters of query strings.
+  - You can embed it as part of a query string, and normally you won't need to do any URI encoding yourself (browser/http client will take care of that).
+  - It will be correctly detected as part of the URI by most auto-URL-from-text implementations.
+- Embeddable:
+  - You can safely put it in `<script>` tags inside single-quoted Javascript strings (unlike JSON)
+  - Added whitespace can simply be removed, it is not used
+- Extensible:
+  - `rich` mode encodes/decodes `Date` objects, `undefined`, `NaN` and `Infinity`
+  - Future: The encoding dictionary can be extended, providing more space optimization
+  - Future: You can provide your own stringify/parse for custom objects
+- Easy upgrade:
+  - Simply replace `JSON.parse` with `JSURL.parse` and `JSON.stringify` with `JSURL.stringify`
+  - Parses JSON as well
+  - A stringify/parse cycle generates the same output as with JSON
+  - (one exception: it always returns a string, even when JSON would return `undefined`)
+  - It will never generate valid JSON except when it's the correct representation
+
+Given its speed and size, it is well-suited to pass JS values to scripts in HTML, like initial data after Server-Side-Rendering. To do so, embed the result inside a single-quoted string (not double-quoted) and parse that in your script.
+
+Some room has been left in the encoding space for special values. If you enable `rich` on the stringifier, it will encode JS Date objects so that they decode as JS Date objects, and later it might support custom encode/decode of your own object types.
 
-JSURL is an alternative to JSON + URL encoding (or JSON + base64 encoding). 
-It makes it handy to pass complex values via URL query parameters.
-
-JSURL has been designed to be:
-
-* Compact: its output is much more compact than JSON + URL encoding (except in pathological cases). 
-  It is even often slightly more compact than regular JSON!
-* Readable: its output is much more readable than JSON + URL encoding.
-* Foolproof: its output only contains characters that are unaffected by URL encoding/decoding. 
-  There is no risk of missing a URL encoding/decoding pass, or of messing up a JSURL string by applying 
-  an extra URL encoding or decoding pass.
-* Easy to generate and parse
-
-## Syntax
-
-Think of it as JSON with the following changes:
+## Examples
 
-* Curly braces (`{` and `}`) replaced by parentheses (`(` and `)`)
-* Square brackets (`[` and `]`) replaced by `(~` and `)`
-* Property names unquoted (but escaped -- see below).
-* String values prefixed by a single quote (`'`) and escaped
-* All other JSON punctuation (colon `:` and comma `,`) replaced by tildes (`~`)
-* An extra tilde (`~`) at the very beginning.
+JSON:
 
-Property names and string values are escaped as follows:
+```json
+{"name": "John Doé", "age": 42, "user": true, "children": ["Mary", "Bill"]}
+```
 
-* Letters, digits, underscore (`_`), hyphen (`-`) and dot (`.`) are preserved.
-* Dollar sign (`$`) is replaced by exclamation mark (`!`)
-* Other characters with UNICODE value <= `0xff` are encoded as `*XX`
-* Characters with UNICODE value > `0xff` are encoded as `**XXXX`
+JSON + URI encoding:
 
-## Examples
+```text
+%7B%22name%22%3A%22John%20Do%C3%22%2C%22age%22%3A42%2C%22user%22%3Atrue%2C%22children%22%3A%5B%22Mary%22%2C%22Bill%22%5D%7D
+```
 
-JSON:
+JSURL:
 
-``` json
-{"name":"John Doe","age":42,"children":["Mary","Bill"]}
+```jsurl
+(name~John_Doé~age~42~user~~children~!Mary~Bill)~
 ```
 
-JSON + URL encoding:
+JSURL + URI encoding:
 
-```
-%7B%22name%22%3A%22John%20Doe%22%2C%22age%22%3A42%2C%22children%22%3A%5B%22Mary%22%2C%22Bill%22%5D%7D
+```text
+(name~John_Do%C3%A9~age~42~user~~children~!Mary~Bill)~
 ```
 
-JSURL:
+## Installing
+
+The easiest way to install `jsurl` is with NPM:
 
-``` jsurl
-~(name~'John*20Doe~age~42~children~(~'Mary~'Bill))
+```sh
+npm install jsurl
 ```
 
 ## API
 
-``` javascript
+```javascript
 var JSURL = require("jsurl");
 
-str = JSURL.stringify(obj);
-obj = JSURL.parse(str);
+// Options:
+// * `rich`: encode Date, `undefined`, `Infinity`
+// * `short`: remove optional trailing delimiters
+str = JSURL.stringify(obj[, options]);
 
-// return def instead of throwing on error
-obj = JSURL.tryParse(str[, def]);
+// Options:
+// * `deURI`: remove URI encoding and whitespace
+obj = JSURL.parse(str[, options]);
+
+// return `default` instead of throwing on error; options are passed to `parse()`
+obj = JSURL.tryParse(str[, default][, options]);
 ```
 
-# Installation
+### Upgrading from version 1
 
-The easiest way to install `jsurl` is with NPM:
+- Version 2 might need extra URI-encoding depending on your needs
+  - You can call `parse(text, {deURI: true})` to handle any URI decoding automatically. This is slower, so only do this if needed.
+- Version 1 encoded text is parsed by v2
+- Version 1 clients will _not_ be able to parse version 2 encoded text, be careful when deploying new encoded text
 
-```sh
-npm install jsurl
+### Version 1
+
+The old v1 API is still available if you need to decode v1 stringifieds.
+
+```javascript
+var JSURL1 = require("jsurl/v1");
+
+str = JSURL1.stringify(obj);
+obj = JSURL1.parse(str);
+
+// return def instead of throwing on error
+obj = JSURL1.tryParse(str[, def]);
 ```
 
+## Syntax
+
+JSURL uses the allowable characters in URI schemes for multiple purposes depending on the location in the result. Some examples:
+
+- `!` starts an array if it is the first character in a value, but inside a string it is unchanged.
+- `~` and `)` are used as end-of-value and end-of-object delimiters, and are illegal inside encoded values.
+- `*` starts a string, but can be left out if the first string character is a-z. Inside a string, it escapes special characters.
+- whitespace is never legal, so you can strip it before parsing if it can be introduced accidentally
+
+JSURL has a `short` mode, which omits the unnecessary ending delimiters. You can use this to save a few more bytes, but you won't be able to spot an encoded value on sight by the ending `~`.
+
+Since browsers may choose to encode any character with URI escaping, and special characters are shown in URLs, no attempt is made to make v2 URI-neutral. Decoding will work no matter how many encodings happened, if you pass the `deURI: true` option to the parser.
+
+## Roadmap
+
+- Indenting
+  - `stringify` adds whitespace (post-process, too slow in parser code)
+- Encoding dictionary
+  - Pass to `parse` and `stringify`
+  - Allow embedding dictionary in encoded output
+    - Only embed used keys
+    - Auto mode that encodes object keys with length > 4
+- Custom encoding
+  - Dictionary of encoders that get called on Objects
+  - First one to return a value other than `undefined` wins
+  - Decoders get called on their encoded values
+- `new JSURL`-based API to prepare custom encoding and dictionary
+- Interactive demo webpage
+  - Examples that you can edit with JSON/JSURL side-by-side
+  - For each example, compare with JSON: length, length when URI encoded, stringify speed, parse speed
+  - Benchmark: generates random objects to encode, average space and time savings
+
 ## License
 
 This work is licensed under the [MIT license](http://en.wikipedia.org/wiki/MIT_License).
diff --git a/__tests__/jsurl.js b/__tests__/jsurl.js
new file mode 100644
index 0000000..de2b10e
--- /dev/null
+++ b/__tests__/jsurl.js
@@ -0,0 +1,132 @@
+const {stringify, parse, tryParse} = require('../v1')
+
+// test macro, both directions
+const cmp = (v, s) => {
+	// regular
+	expect(stringify(v)).toBe(s)
+	// roundtrip
+	expect(stringify(parse(s))).toBe(s)
+}
+
+// basic values
+test('basics', () => {
+	cmp(undefined, undefined)
+	cmp(function() {
+		foo()
+	}, undefined)
+	cmp(null, '~null')
+	cmp(false, '~false')
+	cmp(true, '~true')
+	cmp(0, '~0')
+	cmp(1, '~1')
+	cmp(-1.5, '~-1.5')
+	cmp('hello world\u203c', "~'hello*20world**203c")
+	cmp(
+		' !"#$%&\'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~',
+		"~'*20*21*22*23!*25*26*27*28*29*2a*2b*2c-.*2f09*3a*3b*3c*3d*3e*3f*40AZ*5b*5c*5d*5e_*60az*7b*7c*7d*7e"
+	)
+	// JSON.stringify converts special numeric values to null
+	cmp(NaN, '~null')
+	cmp(Infinity, '~null')
+	cmp(-Infinity, '~null')
+
+	// arrays
+	cmp([], '~(~)')
+	cmp(
+		[
+			undefined,
+			function() {
+				foo()
+			},
+			null,
+			false,
+			0,
+			'hello world\u203c',
+		],
+		"~(~null~null~null~false~0~'hello*20world**203c)"
+	)
+
+	// objects
+	cmp({}, '~()')
+	cmp(
+		{
+			a: undefined,
+			b: function() {
+				foo()
+			},
+			c: null,
+			d: false,
+			e: 0,
+			f: 'hello world\u203c',
+		},
+		"~(c~null~d~false~e~0~f~'hello*20world**203c)"
+	)
+
+	// mix
+	cmp(
+		{
+			a: [[1, 2], [], {}],
+			b: [],
+			c: {
+				d: 'hello',
+				e: {},
+				f: [],
+			},
+		},
+		"~(a~(~(~1~2)~(~)~())~b~(~)~c~(d~'hello~e~()~f~(~)))"
+	)
+})
+
+test('percent-escaped single quotes', () => {
+	expect(parse('~(a~%27hello~b~%27world)')).toEqual({
+		a: 'hello',
+		b: 'world',
+	})
+})
+
+test('percent-escaped percent-escaped single quotes', () => {
+	expect(parse('~(a~%2527hello~b~%2525252527world)')).toEqual({
+		a: 'hello',
+		b: 'world',
+	})
+})
+
+test('tryParse', () => {
+	expect(tryParse('~null')).toBe(null)
+	expect(tryParse('~1', 2)).toBe(1)
+	expect(tryParse('1')).toBe(undefined)
+	expect(tryParse('1', 0)).toBe(0)
+})
+
+test('parse performance', () => {
+	const n = Date.now()
+	const v = {
+		a: [[1, 2], [], false, {}, true],
+		b: [],
+		c: {d: 'hello', e: {}, f: [], g: true, n: null},
+	}
+	const s = stringify(v)
+	const count = 10000
+	for (let i = 0; i < count; i++) {
+		parse(s)
+	}
+	const ms = Date.now() - n
+	console.log(`${count} parsed in ${ms}ms, ${ms / count}ms/item`)
+	expect(ms < 300).toBe(true)
+})
+
+test('stringify performance', () => {
+	const n = Date.now()
+	const v = {
+		a: [[1, 2], [], false, {}, true],
+		b: [],
+		c: {d: 'hello', e: {}, f: [], g: true, n: null},
+	}
+	const count = 10000
+	for (let i = 0; i < count; i++) {
+		stringify(v)
+	}
+	const ms = Date.now() - n
+	console.log(`${count} stringified in ${ms}ms, ${ms / count}ms/item`)
+	expect(ms < 300).toBe(true)
+})
diff --git a/__tests__/jsurl2.js b/__tests__/jsurl2.js
new file mode 100644
index 0000000..7b7ff88
--- /dev/null
+++ b/__tests__/jsurl2.js
@@ -0,0 +1,259 @@
+const blns = require('blns')
+const {stringify, parse, tryParse} = require('..')
+
+// It only produces JSON parseable values if they are the same
+const isJsonOk = (v, str) => {
+	try {
+		const out = JSON.parse(str)
+		return v === out
+	} catch (err) {
+		return true
+	}
+}
+// test macro, both directions
+const cmp = (v, s, short, rich) => {
+	// regular
+	const richStr = stringify(v, {rich})
+	expect(richStr).not.toMatch(/[%?#&=\n\r\0'<\\\u2028]/)
+	if (s) expect([v, richStr]).toEqual([v, s])
+	else s = richStr
+	// roundtrip
+	expect(stringify(parse(s), {rich})).toBe(s)
+	// short
+	const shortStr = stringify(v, {short: true, rich})
+	if (short) expect(shortStr).toBe(short)
+	else short = shortStr
+	expect(stringify(parse(short), {short: true, rich})).toBe(short)
+	// not JSON
+	expect(isJsonOk(v, richStr)).toBe(true)
+	expect(isJsonOk(v, shortStr)).toBe(true)
+	// Can parse the JSON version and is equivalent
+	const jsv = JSON.stringify(v)
+	if (jsv) {
+		if (!rich) expect(parse(jsv)).toEqual(parse(short))
+	} else {
+		expect(jsv).toBe(undefined)
+		expect([v, s]).toEqual([v, '_U~'])
+	}
+}
+cmp.title = (title, v, s) => `${title} ${s}`
+
+test('basics', () => {
+	// basic values
+	cmp(undefined, '_U~', '_U')
+	cmp(
+		function() {
+			foo()
+		},
+		'_U~',
+		'_U'
+	)
+	cmp(null, '_N~', '_N')
+	cmp(false, '_F~', '_F')
+	cmp(true, '~', '')
+	cmp(0, '0~', '0')
+	cmp(1, '1~', '1')
+	cmp(-1.5, '-1.5~', '-1.5')
+	cmp('', '*~', '*')
+	cmp('hello world\u203c', 'hello_world\u203c~', 'hello_world\u203c')
+	cmp(
+		' !"#$%&\'"()*+,-./09:;<=>?@AZ[\\]^_`az{|}\n\r\0\u2028~',
+		'*_!"*H*S*.*A*""*C*D***P,-./09:;*L*E*G*Q@AZ[*B]^*_`az{|}*N*R*Z*U*-~',
+		'*_!"*H*S*.*A*""*C*D***P,-./09:;*L*E*G*Q@AZ[*B]^*_`az{|}*N*R*Z*U*-'
+	)
+	cmp(
+		'Ľồťś ǒƒ ửňìćọđé ẁћəệ!',
+		'*Ľồťś_ǒƒ_ửňìćọđé_ẁћəệ!~',
+		'*Ľồťś_ǒƒ_ửňìćọđé_ẁћəệ!'
+	)
+	// JSON.stringify converts special numeric values to null
+	cmp(NaN, '_N~', '_N')
+	cmp(Infinity, '_N~', '_N')
+	cmp(-Infinity, '_N~', '_N')
+	cmp(NaN, '_n~', '_n', true)
+	cmp(Infinity, '_I~', '_I', true)
+	cmp(-Infinity, '_J~', '_J', true)
+	cmp(
+		new Date(1456898746898),
+		'*2016-03-02T06:05:46.898Z~',
+		'*2016-03-02T06:05:46.898Z'
+	)
+	cmp(
+		new Date('2017-04-01'),
+		'*2017-04-01T00:00:00.000Z~',
+		'*2017-04-01T00:00:00.000Z'
+	)
+	cmp(
+		new Date(1456898746898),
+		'_D2016-03-02T06:05:46.898Z~',
+		'_D2016-03-02T06:05:46.898Z',
+		true
+	)
+	cmp(new Date('2017-04-01'), '_D2017-04-01~', '_D2017-04-01', true)
+
+	// arrays
+	cmp([], '!~', '!')
+	cmp([true], '!_T~', '!_T')
+	cmp(
+		[
+			undefined,
+			function() {
+				foo()
+			},
+			null,
+			false,
+			0,
+			'hello world\u203c',
+		],
+		'!_N~_N~_N~_F~0~hello_world\u203c~',
+		'!_N~_N~_N~_F~0~hello_world\u203c'
+	)
+	cmp(
+		[
+			undefined,
+			function() {
+				foo()
+			},
+			null,
+			false,
+			0,
+			'hello world\u203c',
+		],
+		'!_U~_U~_N~_F~0~hello_world\u203c~',
+		'!_U~_U~_N~_F~0~hello_world\u203c',
+		true
+	)
+
+	// objects
+	cmp({}, '()~', '(')
+	cmp({a: true, b: true, c: true}, '(a~~b~~c)~', '(a~~b~~c')
+	cmp(
+		{
+			a: undefined,
+			b: function() {
+				foo()
+			},
+			c: null,
+			d: false,
+			t: true,
+			e: 0,
+			f: 'hello (world)\u203c',
+		},
+		'(c~_N~d~_F~t~~e~0~f~hello_*Cworld*D\u203c)~',
+		'(c~_N~d~_F~t~~e~0~f~hello_*Cworld*D\u203c'
+	)
+	cmp(
+		{'()': {}, c: {'~': '()'}},
+		'(*C*D~()c~(*-~**C*D))~',
+		'(*C*D~()c~(*-~**C*D'
+	)
+	cmp({a: [[[1]]]}, '(a~!!!1)~', '(a~!!!1')
+	// mix
+	cmp(
+		{
+			a: [[1, 2], [], false, true, {}],
+			c: {
+				d: 'hello',
+				e: {},
+				f: [],
+				g: true,
+				n: null,
+			},
+			b: [],
+		},
+		'(a~!!1~2~~!~_F~_T~()~c~(d~hello~e~()f~!~g~~n~_N)b~!)~',
+		'(a~!!1~2~~!~_F~_T~()~c~(d~hello~e~()f~!~g~~n~_N)b~!'
+	)
+	cmp([[{a: [{b: [[1]]}]}]], '!!(a~!(b~!!1))~', '!!(a~!(b~!!1')
+})
+
+test('percent-escaped single quotes', () => {
+	expect(parse('(a~*%27hello~b~*%27world~)~', {deURI: true})).toEqual({
+		a: "'hello",
+		b: "'world",
+	})
+})
+
+test('percent-escaped percent-escaped single quotes', () => {
+	expect(parse('(a~*%2527hello~b~*%2525252527world~)~', {deURI: true})).toEqual(
+		{
+			a: "'hello",
+			b: "'world",
+		}
+	)
+})
+
+test('whitespace etc', () => {
+	expect(
+		parse('(a~*%00he llo ~ b~ \r \n \f \t *%251fworld~)~', {deURI: true})
+	).toEqual({
+		a: 'hello',
+		b: 'world',
+	})
+})
+
+test('tryParse', () => {
+	expect(tryParse('_N~')).toBe(null)
+	expect(tryParse('%5FN', 5, {deURI: true})).toBe(null)
+	expect(tryParse('1~', 2)).toBe(1)
+	expect(tryParse('_')).toBe(undefined)
+	expect(tryParse('_', 0)).toBe(0)
+	expect(tryParse('12323NOTANUMBER', 0)).toBe(0)
+})
+
+test('parse performance', () => {
+	const n = Date.now()
+	const v = {
+		a: [[1, 2], [], false, {}, true],
+		b: [],
+		c: {d: 'hello', e: {}, f: [], g: true, n: null},
+	}
+	const s = stringify(v)
+	const count = 10000
+	for (let i = 0; i < count; i++) {
+		parse(s, {deURI: true})
+	}
+	const ms = Date.now() - n
+	console.log(`v2: ${count} parsed in ${ms}ms, ${ms / count}ms/item`)
+	expect(ms < 300).toBe(true)
+})
+
+test('stringify performance', () => {
+	const n = Date.now()
+	const v = {
+		a: [[1, 2], [], false, {}, true],
+		b: [],
+		c: {d: 'hello', e: {}, f: [], g: true, n: null},
+	}
+	const count = 10000
+	for (let i = 0; i < count; i++) {
+		stringify(v)
+	}
+	const ms = Date.now() - n
+	console.log(`v2: ${count} stringified in ${ms}ms, ${ms / count}ms/item`)
+	expect(ms < 300).toBe(true)
+})
+
+test('.toJSON()', () => {
+	const o = {
+		s: 'hi',
+		toJSON() {
+			return this.s
+		},
+	}
+	expect(stringify(o)).toBe('hi~')
+})
+
+test('never JSON bareword', () => {
+	expect(stringify('true')).toEqual('true~')
+	expect(stringify('true', {short: true})).toEqual('*true')
+	expect(stringify('false')).toEqual('false~')
+	expect(stringify('false', {short: true})).toEqual('*false')
+	expect(stringify('null')).toEqual('null~')
+	expect(stringify('null', {short: true})).toEqual('*null')
+})
+
+test('naughty strings', () => {
+	expect.hasAssertions()
+	blns.forEach(naughty => cmp(naughty))
+})
diff --git a/bower.json b/bower.json
index 40b808e..3f82f79 100644
--- a/bower.json
+++ b/bower.json
@@ -1,7 +1,7 @@
 {
   "name": "jsurl",
-  "main": "index.js",
-  "version": "0.1.0",
+  "main": "lib/jsurl2.js",
+  "version": "2.0.0-rc1",
   "homepage": "https://github.com/Sage/jsurl",
   "authors": [
     "Bruno Jouhier"
diff --git a/examples/performance.html b/examples/performance.html
new file mode 100644
index 0000000..9a38511
--- /dev/null
+++ b/examples/performance.html
@@ -0,0 +1,69 @@
+<!DOCTYPE HTML>
+<title>JSURL Performance </title>
+<script src="../lib/jsurl.js" type="application/javascript"></script>
+<script src="../lib/jsurl2.js" type="application/javascript"></script>
+<script>
+	const count = 200000
+	const v = { a: [[1, 2], [], false, {}, true], b: [], c: { d: 'hello', e: {}, f: [], g: true, n: null } }
+	const JSONParse = () => {
+		const n = Date.now()
+		const s = JSON.stringify(v)
+		for (let i = 0; i < count; i++) {
+			JSON.parse(s)
+		}
+		const ms = Date.now() - n
+		console.log(`JSON: ${count} parsed in ${ms}ms, ${ms / count}ms/item`)
+	}
+	const JSONStringify = () => {
+		const n = Date.now()
+		for (let i = 0; i < count; i++) {
+			JSON.stringify(v)
+		}
+		const ms = Date.now() - n
+		console.log(`JSON: ${count} stringified in ${ms}ms, ${ms / count}ms/item`)
+	}
+	const v1Parse = () => {
+		const n = Date.now()
+		const s = JSURL1.stringify(v)
+		for (let i = 0; i < count; i++) {
+			JSURL1.parse(s)
+		}
+		const ms = Date.now() - n
+		console.log(`v1: ${count} parsed in ${ms}ms, ${ms / count}ms/item`)
+	}
+	const v1Stringify = () => {
+		const n = Date.now()
+		for (let i = 0; i < count; i++) {
+			JSURL1.stringify(v)
+		}
+		const ms = Date.now() - n
+		console.log(`v1: ${count} stringified in ${ms}ms, ${ms / count}ms/item`)
+	}
+	const v2Parse = () => {
+		const n = Date.now()
+		const s = JSURL.stringify(v)
+		for (let i = 0; i < count; i++) {
+			JSURL.parse(s)
+		}
+		const ms = Date.now() - n
+		console.log(`v2: ${count} parsed in ${ms}ms, ${ms / count}ms/item`)
+	}
+	const v2Stringify = () => {
+		const n = Date.now()
+		for (let j = 0; j < count; j++) {
+			JSURL.stringify(v)
+		}
+		const ms = Date.now() - n
+		console.log(`v2: ${count} stringified in ${ms}ms, ${ms / count}ms/item`)
+	}
+	window.onload = () => {
+		JSONParse()
+		JSONStringify()
+		v1Parse()
+		v1Stringify()
+		v2Parse()
+		v2Stringify()
+	}
+</script>
+
+<p>Use the Chrome Devtools Timeline to profile page load. See JS console for timings.</p>
diff --git a/lib/jsurl.js b/lib/jsurl.js
index 6a89b90..90792d1 100644
--- a/lib/jsurl.js
+++ b/lib/jsurl.js
@@ -25,6 +25,8 @@
 //
 (function(exports) {
 	"use strict";
+	var hasOwnProperty = new Object().hasOwnProperty;
+
 	exports.stringify = function stringify(v) {
 		function encode(s) {
 			return !/[^\w-.]/.test(s) ? s : s.replace(/[^\w-.]/g, function(ch) {
@@ -57,7 +59,7 @@
 					return '~(' + (tmpAry.join('') || '~') + ')';
 				} else {
 					for (var key in v) {
-						if (v.hasOwnProperty(key)) {
+						if (hasOwnProperty.call(v, key)) {
 							var val = stringify(v[key]);
 
 							// skip undefined and functions
@@ -166,4 +168,4 @@
 		}
 	}
 
-})(typeof exports !== 'undefined' ? exports : (window.JSURL = window.JSURL || {}));
+})(typeof exports !== 'undefined' ? exports : (window.JSURL1 = window.JSURL1 || {}));
diff --git a/lib/jsurl2.js b/lib/jsurl2.js
new file mode 100644
index 0000000..c5a3d8e
--- /dev/null
+++ b/lib/jsurl2.js
@@ -0,0 +1,332 @@
+// TODO custom objects, support Set, Map etc
+// TODO custom dictionary
+;(function(exports) {
+	'use strict'
+	var hasOwnProperty = new Object().hasOwnProperty
+	var stringRE = /^[a-zA-Z]/
+	var numRE = /^[\d-]/
+	var TRUE = '_T'
+	var FALSE = '_F'
+	var NULL = '_N'
+	var UNDEF = '_U'
+	var NAN = '_n'
+	var INF = '_I'
+	var NINF = '_J'
+
+	var dict = {
+		T: true,
+		F: false,
+		N: null,
+		U: undefined,
+		n: NaN,
+		I: Infinity,
+		J: -Infinity,
+	}
+
+	var fromEscape = {
+		'*': '*',
+		_: '_',
+		'-': '~',
+		S: '$',
+		P: '+',
+		'"': "'",
+		C: '(', // not necessary but we keep it for symmetry
+		D: ')',
+		L: '<',
+		G: '>', // not necessary but we keep it for symmetry
+		'.': '%',
+		Q: '?',
+		H: '#',
+		A: '&',
+		E: '=',
+		B: '\\',
+		N: '\n',
+		R: '\r',
+		U: '\u2028',
+		Z: '\0',
+	}
+	var toEscape = {
+		'*': '*',
+		_: '_',
+		'~': '-',
+		$: 'S',
+		'+': 'P',
+		"'": '"',
+		'(': 'C',
+		')': 'D',
+		'<': 'L',
+		'>': 'G',
+		'%': '.',
+		'?': 'Q',
+		'#': 'H',
+		'&': 'A',
+		'=': 'E',
+		'\\': 'B',
+		'\n': 'N',
+		'\r': 'R',
+		'\0': 'Z',
+		'\u2028': 'U',
+	}
+	function origChar(s) {
+		if (s === '_') {
+			return ' '
+		}
+		var c = fromEscape[s.charAt(1)]
+		if (!c) {
+			throw new Error('Illegal escape code', s)
+		}
+		return c
+	}
+	function escCode(c) {
+		if (c === ' ') {
+			return '_'
+		}
+		return '*' + toEscape[c]
+	}
+	var escapeRE = /(_|\*.)/g
+	function unescape(s) {
+		// oddly enough, testing first is faster
+		return escapeRE.test(s) ? s.replace(escapeRE, origChar) : s
+	}
+	// First half: encoding chars; second half: URI and script chars
+	var replaceRE = /([*_~$+'() <>%?#&=\\\n\r\0\u2028])/g
+	function escape(s) {
+		// oddly enough, testing first is faster
+		return replaceRE.test(s) ? s.replace(replaceRE, escCode) : s
+	}
+	function eat(a) {
+		var j, c
+		for (
+			j = a.i;
+			j < a.l && ((c = a.s.charAt(j)), c !== '~' && c !== ')');
+			j++
+		) {}
+		var w = a.s.slice(a.i, j)
+		if (c === '~') {
+			j++
+		}
+		a.i = j
+		return w
+	}
+	function peek(a) {
+		return a.s.charAt(a.i)
+	}
+	function eatOne(a) {
+		a.i++
+	}
+	var EOS = {} // unique symbol
+	function decode(a) {
+		var out, k, t
+		var c = peek(a)
+		if (!c) {
+			return EOS
+		}
+		if (c === '(') {
+			eatOne(a)
+			out = {}
+			while (((c = peek(a)), c && c !== ')')) {
+				k = unescape(eat(a))
+				c = peek(a)
+				if (c && c !== ')') {
+					t = decode(a)
+				} else {
+					t = true
+				}
+				out[k] = t
+			}
+			if (c === ')') {
+				eatOne(a)
+			}
+		} else if (c === '!') {
+			eatOne(a)
+			out = []
+			while (((c = peek(a)), c && c !== '~' && c !== ')')) {
+				out.push(decode(a))
+			}
+			if (c === '~') {
+				eatOne(a)
+			}
+		} else if (c === '_') {
+			eatOne(a)
+			k = unescape(eat(a))
+			if (k.charAt(0) === 'D') {
+				out = new Date(k.slice(1))
+			} else if (k in dict) {
+				out = dict[k]
+			} else {
+				throw new Error('Unknown dict reference', k)
+			}
+		} else if (c === '*') {
+			eatOne(a)
+			out = unescape(eat(a))
+		} else if (c === '~') {
+			eatOne(a)
+			out = true
+		} else if (numRE.test(c)) {
+			out = Number(eat(a))
+			if (isNaN(out)) {
+				throw new Error('Not a number', c)
+			}
+		} else if (stringRE.test(c)) {
+			out = unescape(eat(a))
+		} else {
+			throw new Error('Cannot decode part ' + [t].concat(a).join('~'))
+		}
+		return out
+	}
+
+	function encode(v, out, rich, depth) {
+		var t,
+			T = typeof v
+
+		if (T === 'number') {
+			out.push(
+				isFinite(v)
+					? v.toString()
+					: rich
+						? isNaN(v)
+							? NAN
+							: v > 0
+								? INF
+								: NINF
+						: NULL
+			)
+		} else if (T === 'boolean') {
+			out.push(v ? '' : FALSE)
+		} else if (T === 'string') {
+			t = escape(v)
+			if (stringRE.test(t)) {
+				out.push(t)
+			} else {
+				out.push('*' + t)
+			}
+		} else if (T === 'object') {
+			if (!v) {
+				out.push(NULL)
+			} else if (rich && v instanceof Date) {
+				out.push('_D' + v.toJSON().replace('T00:00:00.000Z', ''))
+			} else if (typeof v.toJSON === 'function') {
+				encode(v.toJSON(), out, rich, depth)
+			} else if (Array.isArray(v)) {
+				out.push('!')
+				for (var i = 0; i < v.length; i++) {
+					t = v[i]
+					// Special case: only use full -T~ in arrays
+					if (t === true) {
+						out.push(TRUE)
+					} else {
+						encode(t, out, rich, depth + 1)
+					}
+				}
+				out.push('')
+			} else {
+				out.push('(')
+				for (var key in v) {
+					if (hasOwnProperty.call(v, key)) {
+						t = v[key]
+						if (t !== undefined && typeof t !== 'function') {
+							out.push(escape(key))
+							encode(t, out, rich, depth + 1)
+						}
+					}
+				}
+				while (out[out.length - 1] === '') {
+					out.pop()
+				}
+				out.push(')')
+			}
+		} else {
+			// function or undefined
+			out.push(rich || depth === 0 ? UNDEF : NULL)
+		}
+	}
+
+	var antiJSON = {true: '*true', false: '*false', null: '*null'}
+	exports.stringify = function(v, options) {
+		var out = [],
+			t,
+			str = '',
+			len,
+			sep = false,
+			short = options && options.short,
+			rich = options && options.rich
+		encode(v, out, rich, 0)
+		// until where we have to stringify
+		len = out.length - 1
+		while (((t = out[len]), t === '' || (short && t === ')'))) {
+			len--
+		}
+		// extended join('~')
+		for (var i = 0; i <= len; i++) {
+			t = out[i]
+			if (sep && t !== ')') {
+				str += '~'
+			}
+			str += t
+			sep = !(t === '!' || t === '(' || t === ')')
+		}
+		if (short) {
+			if (str.length < 6) {
+				t = antiJSON[str]
+				if (t) str = t
+			}
+		} else {
+			str += '~'
+		}
+		return str
+	}
+
+	function clean(s) {
+		var out = ''
+		var i = 0
+		var j = 0
+		var c
+		while (i < s.length) {
+			c = s.charCodeAt(i)
+			if (c === 37) {
+				// %
+				if (i > j) out += s.slice(j, i)
+				i++
+				while (c === 37) {
+					c = parseInt(s.slice(i, i + 2), 16)
+					i += 2
+				}
+				if (c > 32) {
+					// not a control character or space
+					out += String.fromCharCode(c)
+				}
+				j = i
+			} else if (c <= 32) {
+				if (i > j) out += s.slice(j, i)
+				i++
+				j = i
+			} else {
+				i++
+			}
+		}
+		if (i > j) out += s.slice(j, i)
+		return out
+	}
+
+	var JSONRE = /^({|\[|"|true$|false$|null$)/
+	exports.parse = function(s, options) {
+		if (options && options.deURI) s = clean(s)
+		if (JSONRE.test(s)) return JSON.parse(s)
+		var l = s.length
+		// if (s.charAt(l - 1) !== '~') {
+		// 	throw new Error('not a JSURL2 string')
+		// }
+		var r = decode({s: s, i: 0, l: l})
+		return r === EOS ? true : r
+	}
+
+	exports.tryParse = function(s, def, options) {
+		try {
+			return exports.parse(s, options)
+		} catch (ex) {
+			return def
+		}
+	}
+})(
+	typeof exports !== 'undefined' ? exports : (window.JSURL = window.JSURL || {})
+)
diff --git a/package.json b/package.json
index f8f9cd7..21d4459 100644
--- a/package.json
+++ b/package.json
@@ -1,20 +1,30 @@
 {
-  "name": "jsurl",
-  "description": "URL friendly JSON-like formatting and parsing",
-  "version": "0.1.4",
-  "license": "MIT",
-  "homepage": "http://github.com/Sage/jsurl",
-  "author": "Bruno Jouhier",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/Sage/jsurl.git"
-  },
-  "devDependencies": {
-    "qunit": "^0.7.7"
-  },
-  "directories": {"lib": "./lib" },
-  "scripts": {
-    "test": "node test"
-  },
-  "main": "index.js"
+	"name": "jsurl",
+	"description": "URL friendly JSON-like formatting and parsing",
+	"version": "2.0.0-rc1",
+	"license": "MIT",
+	"homepage": "http://github.com/Sage/jsurl",
+	"author": "Bruno Jouhier",
+	"repository": {
+		"type": "git",
+		"url": "git://github.com/Sage/jsurl.git"
+	},
+	"main": "lib/jsurl2.js",
+	"dependencies": {},
+	"devDependencies": {
+		"blns": "^2.0.4",
+		"jest": "^23.4.0",
+		"jest-cli": "^23.4.0"
+	},
+	"files": [
+		"lib",
+		"v1.js"
+	],
+	"directories": {
+		"lib": "./lib"
+	},
+	"scripts": {
+		"test": "jest",
+		"test-watch": "jest --watch"
+	}
 }
diff --git a/test/common/jsurlTest.js b/test/common/jsurlTest.js
deleted file mode 100644
index 1e03c80..0000000
--- a/test/common/jsurlTest.js
+++ /dev/null
@@ -1,83 +0,0 @@
-"use strict";
-QUnit.module(module.id);
-
-var JSURL = require("../..");
-var undefined;
-
-function t(v, r) {
-	strictEqual(JSURL.stringify(v), r, "stringify " + (typeof v !== 'object' ? v : JSON.stringify(v)));
-	strictEqual(JSURL.stringify(JSURL.parse(JSURL.stringify(v))), r, "roundtrip " + (typeof v !== 'object' ? v : JSON.stringify(v)));
-}
-
-test('basic values', 26, function() {
-	t(undefined, undefined);
-	t(function() {
-		foo();
-	}, undefined);
-	t(null, "~null");
-	t(false, "~false");
-	t(true, "~true");
-	t(0, "~0");
-	t(1, "~1");
-	t(-1.5, "~-1.5");
-	t("hello world\u203c", "~'hello*20world**203c");
-	t(" !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~", "~'*20*21*22*23!*25*26*27*28*29*2a*2b*2c-.*2f09*3a*3b*3c*3d*3e*3f*40AZ*5b*5c*5d*5e_*60az*7b*7c*7d*7e");
-	// JSON.stringify converts special numeric values to null
-	t(NaN, "~null");
-	t(Infinity, "~null");
-	t(-Infinity, "~null");
-});
-test('arrays', 4, function() {
-	t([], "~(~)");
-	t([undefined, function() {
-		foo();
-	},
-	null, false, 0, "hello world\u203c"], "~(~null~null~null~false~0~'hello*20world**203c)");
-});
-test('objects', 4, function() {
-	t({}, "~()");
-	t({
-		a: undefined,
-		b: function() {
-			foo();
-		},
-		c: null,
-		d: false,
-		e: 0,
-		f: "hello world\u203c"
-	}, "~(c~null~d~false~e~0~f~'hello*20world**203c)");
-});
-test('mix', 2, function() {
-	t({
-		a: [
-			[1, 2],
-			[], {}],
-		b: [],
-		c: {
-			d: "hello",
-			e: {},
-			f: []
-		}
-	}, "~(a~(~(~1~2)~(~)~())~b~(~)~c~(d~'hello~e~()~f~(~)))");
-});
-
-test('percent-escaped single quotes', 1, function() {
-	deepEqual(JSURL.parse("~(a~%27hello~b~%27world)"), {
-		a: 'hello',
-		b: 'world'
-	});
-});
-
-test('percent-escaped percent-escaped single quotes', 1, function() {
-	deepEqual(JSURL.parse("~(a~%2527hello~b~%2525252527world)"), {
-		a: 'hello',
-		b: 'world'
-	});
-});
-
-test('tryParse', 4, function() {
-	strictEqual(JSURL.tryParse("~null"), null);
-	strictEqual(JSURL.tryParse("~1", 2), 1);
-	strictEqual(JSURL.tryParse("1"), undefined);
-	strictEqual(JSURL.tryParse("1", 0), 0);
-});
diff --git a/test/index.js b/test/index.js
deleted file mode 100644
index 97e5741..0000000
--- a/test/index.js
+++ /dev/null
@@ -1,25 +0,0 @@
-"use strict";
-
-var fs = require('fs');
-var fsp = require('path');
-
-var root = fsp.join(__dirname, 'common');
-var tests = fs.readdirSync(root).filter(function(file) {
-	return /\.js$/.test(file);
-}).map(function(file) {
-	return fsp.join(root, file);
-});
-
-var testrunner = require("qunit");
-
-process.on('uncaughtException', function(err) {
-	console.error(err.stack);
-	process.exit(1);
-});
-
-testrunner.run({
-	code: '',
-    tests: tests,
-}, function(err) {
-	if (err) throw err;
-});
diff --git a/index.js b/v1.js
similarity index 100%
rename from index.js
rename to v1.js