flok 0.0.12 → 0.0.14

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/engine.io/node_modules/engine.io-parser/node_modules/utf8/LICENSE-MIT.txt

@@ -0,0 +1,20 @@
+Copyright Mathias Bynens <http://mathiasbynens.be/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/engine.io/node_modules/engine.io-parser/node_modules/utf8/README.md

@@ -0,0 +1,119 @@
+# utf8.js [![Build status](https://travis-ci.org/mathiasbynens/utf8.js.png?branch=master)](https://travis-ci.org/mathiasbynens/utf8.js) [![Dependency status](https://gemnasium.com/mathiasbynens/utf8.js.png)](https://gemnasium.com/mathiasbynens/utf8.js)
+
+_utf8.js_ is a well-tested UTF-8 encoder/decoder written in JavaScript. Unlike many other JavaScript solutions, it is designed to be a _proper_ UTF-8 encoder/decoder: it can encode/decode any given Unicode code point, including astral symbols and unpaired surrogates.
+
+Feel free to fork if you see possible improvements!
+
+## Installation
+
+Via [npm](http://npmjs.org/):
+
+```bash
+npm install utf8
+```
+
+Via [Bower](http://bower.io/):
+
+```bash
+bower install utf8
+```
+
+Via [Component](https://github.com/component/component):
+
+```bash
+component install mathiasbynens/utf8.js
+```
+
+In a browser:
+
+```html
+<script src="utf8.js"></script>
+```
+
+In [Narwhal](http://narwhaljs.org/), [Node.js](http://nodejs.org/), and [RingoJS ≥ v0.8.0](http://ringojs.org/):
+
+```js
+var utf8 = require('utf8');
+```
+
+In [Rhino](http://www.mozilla.org/rhino/):
+
+```js
+load('utf8.js');
+```
+
+Using an AMD loader like [RequireJS](http://requirejs.org/):
+
+```js
+require(
+  {
+    'paths': {
+      'utf8': 'path/to/utf8'
+    }
+  },
+  ['utf8'],
+  function(utf8) {
+    console.log(utf8);
+  }
+);
+```
+
+## API
+
+### `utf8.encode(string)`
+
+Encodes any given JavaScript string (`string`) as UTF-8, and returns the UTF-8-encoded version of the string.
+
+```js
+// U+00A9 COPYRIGHT SIGN; see http://codepoints.net/U+00A9
+utf8.encode('\xA9');
+// → '\xC2\xA9'
+// U+10001 LINEAR B SYLLABLE B038 E; see http://codepoints.net/U+10001
+utf8.encode('\uD800\uDC01');
+// → '\xF0\x90\x80\x81'
+```
+
+### `utf8.decode(byteString)`
+
+Encodes any given UTF-8-encoded string (`byteString`) as UTF-8, and returns the UTF-8-decoded version of the string. It throws an error when malformed UTF-8 is detected.
+
+```js
+utf8.decode('\xC2\xA9');
+// → '\xA9'
+
+utf8.decode('\xF0\x90\x80\x81');
+// → '\uD800\uDC01'
+// → U+10001 LINEAR B SYLLABLE B038 E
+```
+
+### `utf8.version`
+
+A string representing the semantic version number.
+
+## Support
+
+utf8.js has been tested in at least Chrome 27-29, Firefox 3-22, Safari 4-6, Opera 10-12, IE 6-10, Node.js v0.10.0, Narwhal 0.3.2, RingoJS 0.8-0.9, PhantomJS 1.9.0, and Rhino 1.7RC4.
+
+## Unit tests & code coverage
+
+After cloning this repository, run `npm install` to install the dependencies needed for development and testing. You may want to install Istanbul _globally_ using `npm install istanbul -g`.
+
+Once that’s done, you can run the unit tests in Node using `npm test` or `node tests/tests.js`. To run the tests in Rhino, Ringo, Narwhal, PhantomJS, and web browsers as well, use `grunt test`.
+
+To generate [the code coverage report](http://rawgithub.com/mathiasbynens/utf8.js/master/coverage/utf8.js/utf8.js.html), use `grunt cover`.
+
+## FAQ
+
+### Why is the first release named v2.0.0? Haven’t you heard of [semantic versioning](http://semver.org/)?
+
+Long before utf8.js was created, the `utf8` module on npm was registered and used by another (slightly buggy) library. @ryanmcgrath was kind enough to give me access to the `utf8` package on npm when I told him about utf8.js. Since there has already been a v1.0.0 release of the old library, and to avoid breaking backwards compatibility with projects that rely on the `utf8` npm package, I decided the tag the first release of utf8.js as v2.0.0 and take it from there.
+
+## Author
+
+| [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](http://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|
+| [Mathias Bynens](http://mathiasbynens.be/) |
+
+## License
+
+utf8.js is dual licensed under the [MIT](http://mths.be/mit) and [GPL](http://mths.be/gpl) licenses.

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/engine.io/node_modules/engine.io-parser/node_modules/utf8/bower.json

@@ -0,0 +1,14 @@
+{
+	"name": "utf8",
+	"version": "2.0.0",
+	"main": "utf8.js",
+	"ignore": [
+		"coverage",
+		"tests",
+		".*",
+		"component.json",
+		"Gruntfile.js",
+		"node_modules",
+		"package.json"
+	]
+}

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/engine.io/node_modules/engine.io-parser/node_modules/utf8/component.json

@@ -0,0 +1,16 @@
+{
+	"name": "utf8",
+	"version": "2.0.0",
+	"description": "A well-tested UTF-8 encoder/decoder written in JavaScript.",
+	"repo": "mathiasbynens/utf8.js",
+	"license": "MIT/GPL",
+	"scripts": [
+		"utf8.js"
+	],
+	"keywords": [
+		"charset",
+		"encoding",
+		"unicode",
+		"utf8"
+	]
+}

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/engine.io/node_modules/engine.io-parser/node_modules/utf8/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "utf8",
+  "version": "2.0.0",
+  "description": "A well-tested UTF-8 encoder/decoder written in JavaScript.",
+  "homepage": "http://mths.be/utf8js",
+  "main": "utf8.js",
+  "keywords": [
+    "charset",
+    "encoding",
+    "unicode",
+    "utf8"
+  ],
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://mths.be/mit"
+    },
+    {
+      "type": "GPL",
+      "url": "http://mths.be/gpl"
+    }
+  ],
+  "author": {
+    "name": "Mathias Bynens",
+    "url": "http://mathiasbynens.be/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mathiasbynens/utf8.js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mathiasbynens/utf8.js/issues"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "node tests/tests.js"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "grunt": "~0.4.1",
+    "grunt-shell": "~0.2.2",
+    "istanbul": "~0.1.36",
+    "qunit-clib": "~1.3.0",
+    "qunitjs": "~1.11.0",
+    "requirejs": "~2.1.6"
+  },
+  "_id": "utf8@2.0.0",
+  "dist": {
+    "shasum": "79ce59eced874809cab9a71fc7102c7d45d4118d",
+    "tarball": "http://registry.npmjs.org/utf8/-/utf8-2.0.0.tgz"
+  },
+  "_from": "utf8@2.0.0",
+  "_npmVersion": "1.2.30",
+  "_npmUser": {
+    "name": "mathias",
+    "email": "mathias@qiwi.be"
+  },
+  "maintainers": [
+    {
+      "name": "ryanmcgrath",
+      "email": "ryan@venodesigns.net"
+    },
+    {
+      "name": "mathias",
+      "email": "mathias@qiwi.be"
+    }
+  ],
+  "_shasum": "79ce59eced874809cab9a71fc7102c7d45d4118d",
+  "_resolved": "https://registry.npmjs.org/utf8/-/utf8-2.0.0.tgz",
+  "readme": "ERROR: No README data found!"
+}

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/engine.io/node_modules/engine.io-parser/node_modules/utf8/tests/generate-test-data.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+
+import re
+import json
+
+# http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+# http://stackoverflow.com/a/13436167/96656
+def unisymbol(codePoint):
+	if codePoint >= 0x0000 and codePoint <= 0xFFFF:
+		return unichr(codePoint)
+	elif codePoint >= 0x010000 and codePoint <= 0x10FFFF:
+		highSurrogate = int((codePoint - 0x10000) / 0x400) + 0xD800
+		lowSurrogate = int((codePoint - 0x10000) % 0x400) + 0xDC00
+		return unichr(highSurrogate) + unichr(lowSurrogate)
+	else:
+		return 'Error'
+
+def hexify(codePoint):
+	return 'U+' + hex(codePoint)[2:].upper().zfill(6)
+
+def writeFile(filename, contents):
+	print filename
+	with open(filename, 'w') as f:
+		f.write(contents.strip() + '\n')
+
+data = []
+for codePoint in range(0x000000, 0x10FFFF + 1):
+	symbol = unisymbol(codePoint)
+	# http://stackoverflow.com/a/17199950/96656
+	bytes = symbol.encode('utf8').decode('latin1')
+	data.append({
+		'codePoint': codePoint,
+		'decoded': symbol,
+		'encoded': bytes
+	});
+
+jsonData = json.dumps(data, sort_keys=False, indent=2, separators=(',', ': '))
+# Use tabs instead of double spaces for indentation
+jsonData = jsonData.replace('  ', '\t')
+# Escape hexadecimal digits in escape sequences
+jsonData = re.sub(
+	r'\\u([a-fA-F0-9]{4})',
+	lambda match: r'\u{}'.format(match.group(1).upper()),
+	jsonData
+)
+
+writeFile('data.json', jsonData)

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/engine.io/node_modules/engine.io-parser/node_modules/utf8/tests/index.html

@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8">
+		<title>utf8.js test suite</title>
+		<link rel="stylesheet" href="../node_modules/qunitjs/qunit/qunit.css">
+	</head>
+	<body>
+		<div id="qunit"></div>
+		<script src="../node_modules/qunitjs/qunit/qunit.js"></script>
+		<script src="../utf8.js"></script>
+		<script>
+			// populate `QUnit.urlParams`
+			QUnit.urlParams.norequire = /[?&]norequire=true(?:&|$)/.test(location.search);
+
+			// load tests.js if not using require.js
+			document.write(QUnit.urlParams.norequire
+				? '<script src="tests.js"><\/script>'
+				: '<script src="../node_modules/requirejs/require.js"><\/script>'
+			);
+		</script>
+		<script>
+			window.require && require({
+				'baseUrl': '../node_modules/requirejs/',
+				'urlArgs': 't=' + (+new Date),
+				'paths': {
+					'utf8': '../../utf8'
+				}
+			},
+			['utf8'], function(utf8) {
+				require(['tests.js']);
+			});
+		</script>
+	</body>
+</html>

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/engine.io/node_modules/engine.io-parser/node_modules/utf8/tests/tests.js

@@ -0,0 +1,242 @@
+;(function(root) {
+	'use strict';
+
+	/** Use a single `load` function */
+	var load = typeof require == 'function' ? require : root.load;
+
+	/** The unit testing framework */
+	var QUnit = (function() {
+		var noop = Function.prototype;
+		return root.QUnit || (
+			root.addEventListener || (root.addEventListener = noop),
+			root.setTimeout || (root.setTimeout = noop),
+			root.QUnit = load('../node_modules/qunitjs/qunit/qunit.js') || root.QUnit,
+			(load('../node_modules/qunit-clib/qunit-clib.js') || { 'runInContext': noop }).runInContext(root),
+			addEventListener === noop && delete root.addEventListener,
+			root.QUnit
+		);
+	}());
+
+	/** The `utf8` object to test */
+	var utf8 = root.utf8 || (root.utf8 = (
+		utf8 = load('../utf8.js') || root.utf8,
+		utf8 = utf8.utf8 || utf8
+	));
+
+	/*--------------------------------------------------------------------------*/
+
+	function forEach(array, fn) {
+		var index = -1;
+		var length = array.length;
+		while (++index < length) {
+			fn(array[index]);
+		}
+	}
+
+	// Quick and dirty test to see if we’re in Node & need extended tests
+	var runExtendedTests = (function() {
+		try {
+			return process.argv[0] == 'node' && process.argv[2] == '--extended';
+		} catch(error) { }
+	}());
+
+	var data = [
+		// 1-byte
+		{
+			'codePoint': 0x0000,
+			'decoded': '\0',
+			'encoded': '\0'
+		},
+		{
+			'codePoint': 0x005C,
+			'decoded': '\x5C',
+			'encoded': '\x5C'
+		},
+		{
+			'codePoint': 0x007F,
+			'decoded': '\x7F',
+			'encoded': '\x7F'
+		},
+
+		// 2-byte
+		{
+			'codePoint': 0x0080,
+			'decoded': '\x80',
+			'encoded': '\xC2\x80'
+		},
+		{
+			'codePoint': 0x05CA,
+			'decoded': '\u05CA',
+			'encoded': '\xD7\x8A'
+		},
+		{
+			'codePoint': 0x07FF,
+			'decoded': '\u07FF',
+			'encoded': '\xDF\xBF',
+		},
+
+		// 3-byte
+		{
+			'codePoint': 0x0800,
+			'decoded': '\u0800',
+			'encoded': '\xE0\xA0\x80',
+		},
+		{
+			'codePoint': 0x2C3C,
+			'decoded': '\u2C3C',
+			'encoded': '\xE2\xB0\xBC'
+		},
+		{
+			'codePoint': 0xFFFF,
+			'decoded': '\uFFFF',
+			'encoded': '\xEF\xBF\xBF'
+		},
+		// unmatched surrogate halves
+		// high surrogates: 0xD800 to 0xDBFF
+		{
+			'codePoint': 0xD800,
+			'decoded': '\uD800',
+			'encoded': '\xED\xA0\x80'
+		},
+		{
+			'description': 'High surrogate followed by another high surrogate',
+			'decoded': '\uD800\uD800',
+			'encoded': '\xED\xA0\x80\xED\xA0\x80'
+		},
+		{
+			'description': 'High surrogate followed by a symbol that is not a surrogate',
+			'decoded': '\uD800A',
+			'encoded': '\xED\xA0\x80A'
+		},
+		{
+			'description': 'Unmatched high surrogate, followed by a surrogate pair, followed by an unmatched high surrogate',
+			'decoded': '\uD800\uD834\uDF06\uD800',
+			'encoded': '\xED\xA0\x80\xF0\x9D\x8C\x86\xED\xA0\x80'
+		},
+		{
+			'codePoint': 0xD9AF,
+			'decoded': '\uD9AF',
+			'encoded': '\xED\xA6\xAF'
+		},
+		{
+			'codePoint': 0xDBFF,
+			'decoded': '\uDBFF',
+			'encoded': '\xED\xAF\xBF'
+		},
+		// low surrogates: 0xDC00 to 0xDFFF
+		{
+			'codePoint': 0xDC00,
+			'decoded': '\uDC00',
+			'encoded': '\xED\xB0\x80'
+		},
+		{
+			'description': 'Low surrogate followed by another low surrogate',
+			'decoded': '\uDC00\uDC00',
+			'encoded': '\xED\xB0\x80\xED\xB0\x80'
+		},
+		{
+			'description': 'Low surrogate followed by a symbol that is not a surrogate',
+			'decoded': '\uDC00A',
+			'encoded': '\xED\xB0\x80A'
+		},
+		{
+			'description': 'Unmatched low surrogate, followed by a surrogate pair, followed by an unmatched low surrogate',
+			'decoded': '\uDC00\uD834\uDF06\uDC00',
+			'encoded': '\xED\xB0\x80\xF0\x9D\x8C\x86\xED\xB0\x80'
+		},
+		{
+			'codePoint': 0xDEEE,
+			'decoded': '\uDEEE',
+			'encoded': '\xED\xBB\xAE'
+		},
+		{
+			'codePoint': 0xDFFF,
+			'decoded': '\uDFFF',
+			'encoded': '\xED\xBF\xBF'
+		},
+
+		// 4-byte
+		{
+			'codePoint': 0x010000,
+			'decoded': '\uD800\uDC00',
+			'encoded': '\xF0\x90\x80\x80'
+		},
+		{
+			'codePoint': 0x01D306,
+			'decoded': '\uD834\uDF06',
+			'encoded': '\xF0\x9D\x8C\x86'
+		},
+		{
+			'codePoint': 0x10FFF,
+			'decoded': '\uDBFF\uDFFF',
+			'encoded': '\xF4\x8F\xBF\xBF'
+		}
+	];
+
+	if (runExtendedTests) {
+		data = data.concat(require('./data.json'));
+	}
+
+	// `throws` is a reserved word in ES3; alias it to avoid errors
+	var raises = QUnit.assert['throws'];
+
+	// explicitly call `QUnit.module()` instead of `module()`
+	// in case we are in a CLI environment
+	QUnit.module('utf8.js');
+
+	test('encode/decode', function() {
+		forEach(data, function(object) {
+			var description = object.description || 'U+' + object.codePoint.toString(16).toUpperCase();
+			;
+			equal(
+				object.encoded,
+				utf8.encode(object.decoded),
+				'Encoding: ' + description
+			);
+			equal(
+				object.decoded,
+				utf8.decode(object.encoded),
+				'Decoding: ' + description
+			);
+		});
+
+		// Error handling
+		raises(
+			function() {
+				utf8.decode('\uFFFF');
+			},
+			Error,
+			'Error: invalid UTF-8 detected'
+		);
+		raises(
+			function() {
+				utf8.decode('\xE9\x00\x00');
+			},
+			Error,
+			'Error: invalid continuation byte (4-byte sequence expected)'
+		);
+		raises(
+			function() {
+				utf8.decode('\xC2\uFFFF');
+			},
+			Error,
+			'Error: invalid continuation byte'
+		);
+		raises(
+			function() {
+				utf8.decode('\xF0\x9D');
+			},
+			Error,
+			'Error: invalid byte index'
+		);
+	});
+
+	/*--------------------------------------------------------------------------*/
+
+	// configure QUnit and call `QUnit.start()` for
+	// Narwhal, Node.js, PhantomJS, Rhino, and RingoJS
+	if (!root.document || root.phantom) {
+		QUnit.config.noglobals = true;
+		QUnit.start();
+	}
+}(typeof global == 'object' && global || this));