From 363723fc84f7b8477592e0105aeb331ec9a017af Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Mon, 14 Aug 2017 05:01:11 +0200 Subject: node_modules --- node_modules/structured-clone/.npmignore | 2 + node_modules/structured-clone/LICENSE | 21 +++ node_modules/structured-clone/README.md | 36 +++++ node_modules/structured-clone/clone.js | 38 +++++ node_modules/structured-clone/index.js | 6 + node_modules/structured-clone/package.json | 16 +++ node_modules/structured-clone/serialize.js | 223 +++++++++++++++++++++++++++++ node_modules/structured-clone/test/test.js | 100 +++++++++++++ 8 files changed, 442 insertions(+) create mode 100644 node_modules/structured-clone/.npmignore create mode 100644 node_modules/structured-clone/LICENSE create mode 100644 node_modules/structured-clone/README.md create mode 100644 node_modules/structured-clone/clone.js create mode 100644 node_modules/structured-clone/index.js create mode 100644 node_modules/structured-clone/package.json create mode 100644 node_modules/structured-clone/serialize.js create mode 100644 node_modules/structured-clone/test/test.js (limited to 'node_modules/structured-clone') diff --git a/node_modules/structured-clone/.npmignore b/node_modules/structured-clone/.npmignore new file mode 100644 index 000000000..3351ce2e9 --- /dev/null +++ b/node_modules/structured-clone/.npmignore @@ -0,0 +1,2 @@ +*.log +node_modules diff --git a/node_modules/structured-clone/LICENSE b/node_modules/structured-clone/LICENSE new file mode 100644 index 000000000..fca65eaff --- /dev/null +++ b/node_modules/structured-clone/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Technical Machine, Inc. + +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. \ No newline at end of file diff --git a/node_modules/structured-clone/README.md b/node_modules/structured-clone/README.md new file mode 100644 index 000000000..0e70f6982 --- /dev/null +++ b/node_modules/structured-clone/README.md @@ -0,0 +1,36 @@ +# structured-clone + +Implements the [structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/The_structured_clone_algorithm). Clone JSON types, RegExp, Buffers, and Dates, returning a cloned object or a buffer that can be deserialized into a structured clone + +``` +npm install structured-clone +``` + +```js +var clone = require('structured-clone'); +``` + +* **clone**(obj) → *Object* +* clone.**serialize**(obj) → *Buffer* +* clone.**deserialize**(buf) → *Object* + +## Encoded format + +The encoded format takes this form: + +1. A UTF-8 encoded JSON string. +2. A null byte. +3. A binary blob that is the concatenation of all binary buffers in the original object. There are no delimiters in this buffer, indexes are represented in the JSON value (see below). + +Dates, regexps, buffers, and cycles are encoded in a particular way to be decoded properly: + +- Dates are encoded as the string '\x10d' followed by the JSON-stringified encoding of the date. +- Regexps are encoded as the string '\x10r{flags},{regexp source}'. +- Buffers are encoded as the string '\x10b{start},{length}'. All buffers in the encoded value are concatenated and placed in the binary blob. The start and length parameters indicate the indexes the slice of the buffer was encoded in. +- Lastly, string that begin with '\x10' are encoded as '\x10s{string}' to properly escape them. + +**Optimizations:** If only a JSON value is being encoded (i.e. no Buffer values included), the null byte can be omitted, thus making the encoded format equivalent to a JSON-encoded string. If only a buffer is being encoded, it is equivalent to a null byte followed by the buffer (i.e. the JSON string is 0-length). + +## License + +MIT \ No newline at end of file diff --git a/node_modules/structured-clone/clone.js b/node_modules/structured-clone/clone.js new file mode 100644 index 000000000..df1e4884e --- /dev/null +++ b/node_modules/structured-clone/clone.js @@ -0,0 +1,38 @@ +// Implement the clone algorithm directly. +// https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/The_structured_clone_algorithm + +function clone (oToBeCloned, cloned, clonedpairs) +{ + cloned = cloned || []; + clonedpairs = clonedpairs || []; + + if (cloned.indexOf(oToBeCloned) > -1) { + return clonedpairs[cloned.indexOf(oToBeCloned)]; + } + + if (oToBeCloned === null || !(oToBeCloned instanceof Object)) { return oToBeCloned; } + var oClone, fConstr = oToBeCloned.constructor; + switch (fConstr) { + case RegExp: + oClone = new fConstr(oToBeCloned.source, "g".substr(0, Number(oToBeCloned.global)) + "i".substr(0, Number(oToBeCloned.ignoreCase)) + "m".substr(0, Number(oToBeCloned.multiline))); + break; + case Date: + oClone = new fConstr(oToBeCloned.getTime()); + break; + // etc. + default: + if (Buffer.isBuffer(oToBeCloned)) { + oClone = new Buffer(oToBeCloned.length); + oToBeCloned.copy(oClone); + } else if (oToBeCloned instanceof Error) { + oClone = new Error(oToBeCloned.message); + } else { + oClone = new fConstr(); + cloned.push(oToBeCloned); clonedpairs.push(oClone); + for (var sProp in oToBeCloned) { oClone[sProp] = clone(oToBeCloned[sProp], cloned, clonedpairs); } + } + } + return oClone; +} + +exports.clone = clone; \ No newline at end of file diff --git a/node_modules/structured-clone/index.js b/node_modules/structured-clone/index.js new file mode 100644 index 000000000..50d17f7f3 --- /dev/null +++ b/node_modules/structured-clone/index.js @@ -0,0 +1,6 @@ +// Public API. + +module.exports = require('./clone').clone; +module.exports.clone = require('./clone').clone; +module.exports.serialize = require('./serialize').serialize; +module.exports.deserialize = require('./serialize').deserialize; \ No newline at end of file diff --git a/node_modules/structured-clone/package.json b/node_modules/structured-clone/package.json new file mode 100644 index 000000000..cb9c8d952 --- /dev/null +++ b/node_modules/structured-clone/package.json @@ -0,0 +1,16 @@ +{ + "name": "structured-clone", + "version": "0.2.2", + "repository": "tessel/structured-clone", + "description": "Implements the structured clone algorithm. Clone JSON types, RegExp, Buffers, and Dates, returning a cloned object or a buffer that can be deserialized into a structured clone.", + "main": "index.js", + "scripts": { + "test": "node_modules/.bin/tap test/*.js" + }, + "author": "Tim Cameron Ryan ", + "license": "MIT", + "devDependencies": { + "tap": "~0.4.8", + "tape": "~2.10.2" + } +} diff --git a/node_modules/structured-clone/serialize.js b/node_modules/structured-clone/serialize.js new file mode 100644 index 000000000..44c984f38 --- /dev/null +++ b/node_modules/structured-clone/serialize.js @@ -0,0 +1,223 @@ +// Implements serialize/deserialize of structured clones. +// Also resolves cycles (code based on cycle.js by Douglas Crockford) + +function encodeRegExp (regexp) +{ + var flags = ''; + if (regexp.global) flags += 'g'; + if (regexp.multiline) flags += 'm'; + if (regexp.ignoreCase) flags += 'i'; + return [flags, regexp.source].join(','); +} + +function decodeRegExp (str) +{ + var flags = str.match(/^[^,]*/)[0]; + var source = str.substr(flags.length + 1); + return new RegExp(source, flags); +} + + +// The derez recurses through the object, producing the deep copy. + +function derez(value, path, objects, paths, buffers) +{ + if (Buffer.isBuffer(value)) { + var start = Buffer.concat(buffers).length; + buffers.push(value); + return '\x10b' + [start, value.length].join(',') + } + if (value instanceof Date) { + return '\x10d' + value.toJSON(); + } + if (value instanceof RegExp) { + return '\x10r' + encodeRegExp(value); + } + if (value instanceof Error) { + return '\x10e' + value.message + } + if (typeof value == 'string') { + return value.charAt(0) == '\x10' ? '\x10s' + value : value; + } + + var i, // The loop counter + name, // Property name + nu; // The new object or array + +// typeof null === 'object', so go on if this value is really an object but not +// one of the weird builtin objects. + + if (typeof value === 'object' && value !== null && + !(value instanceof Boolean) && + !(value instanceof Number) && + !(value instanceof String)) { + +// If the value is an object or array, look to see if we have already +// encountered it. If so, return a $ref/path object. This is a hard way, +// linear search that will get slower as the number of unique objects grows. + + i = objects.indexOf(value); + if (i !== -1) { + return '\x10j' + paths[i]; + } + +// Otherwise, accumulate the unique value and its path. + + objects.push(value); + paths.push(path); + +// If it is an array, replicate the array. + + if (Array.isArray(value)) { + nu = []; + for (i = 0; i < value.length; i += 1) { + nu[i] = derez(value[i], + path + '[' + i + ']', + objects, paths, buffers); + } + } else { + +// If it is an object, replicate the object. + + nu = {}; + for (name in value) { + if (Object.prototype.hasOwnProperty.call(value, name) && value != '__proto__') { + nu[name] = derez(value[name], + path + '[' + JSON.stringify(name) + ']', + objects, paths, buffers); + } + } + } + return nu; + } + + return value; +} + + +function rerez($, $$) +{ + +// Restore an object that was reduced by decycle. Members whose values are +// objects of the form +// {$ref: PATH} +// are replaced with references to the value found by the PATH. This will +// restore cycles. The object will be mutated. + +// The eval function is used to locate the values described by a PATH. The +// root object is kept in a $ variable. A regular expression is used to +// assure that the PATH is extremely well formed. The regexp contains nested +// * quantifiers. That has been known to have extremely bad performance +// problems on some browsers for very long strings. A PATH is expected to be +// reasonably short. A PATH is allowed to belong to a very restricted subset of +// Goessner's JSONPath. + +// So, +// var s = '[{"$ref":"$"}]'; +// return JSON.retrocycle(JSON.parse(s)); +// produces an array containing a single element which is the array itself. + + var px = + /^\${1,4}(?:\[(?:\d+|\"(?:[^\\\"\u0000-\u001f]|\\([\\\"\/bfnrt]|u[0-9a-zA-Z]{4}))*\")\])*$/; + + function redo (item) { + if (typeof item == 'string' && item.charAt(0) == '\x10') { + switch (item.charAt(1)) { + case 's': + return item.substr(2); + case 'b': + var bounds = item.substr(2).split(',', 2); + return $$.slice(bounds[0] || 0, (bounds[0] || 0) + (bounds[1] || [0])); + case 'd': + return new Date(item.substr(2)); + case 'r': + return decodeRegExp(item.substr(2)); + case 'e': + return new Error(item.substr(2)); + case 'j': + var path = item.substr(2); + if (px.test(path)) { + return eval(path); + } + default: return null; + } + } + + if (item && typeof item === 'object') { + rez(item, $$); + } + return item; + } + + function rez(value) { + +// The rez function walks recursively through the object looking for $ref +// properties. When it finds one that has a value that is a path, then it +// replaces the $ref object with a reference to the value that is found by +// the path. + + var i, name; + + if (value && typeof value === 'object') { + if (Array.isArray(value)) { + for (i = 0; i < value.length; i += 1) { + value[i] = redo(value[i]); + } + } else { + for (name in value) { + value[name] = redo(value[name]); + } + } + } + } + + $ = redo($) + + return $; +}; + + +// Public API + +exports.serialize = function (object) { + var objects = [], // Keep a reference to each unique object or array + paths = [], // Keep the path to each unique object or array + buffers = []; // Returned buffers + + var nilbyte = new Buffer([0x00]); + + if (Buffer.isBuffer(object)) { + return Buffer.concat([ + nilbyte, + object + ]); + } + + var json = new Buffer(JSON.stringify(derez(object, '$', objects, paths, buffers))); + if (buffers.length == 0) { + return json; + } + + return Buffer.concat([ + json, + nilbyte, + Buffer.concat(buffers) + ]); +} + +exports.deserialize = function (buf) { + for (var i = 0; i <= buf.length; i++) { + if (buf[i] == 0x00 || buf[i] == null) { + break; + } + } + var jsonbuf = buf.slice(0, i); + var bufbuf = buf.slice(i + 1); + + // Shortcut for only encoding a root buffer. + if (jsonbuf.length == 0) { + return bufbuf; + } + + return rerez(JSON.parse(jsonbuf.toString('utf-8')), bufbuf); +} \ No newline at end of file diff --git a/node_modules/structured-clone/test/test.js b/node_modules/structured-clone/test/test.js new file mode 100644 index 000000000..1a201e572 --- /dev/null +++ b/node_modules/structured-clone/test/test.js @@ -0,0 +1,100 @@ +var test = require('tape'); + +test('deep cloning test', function (t) { + t.plan(12) + + var clone = require('../') + + var a = { } + a.b = a + a.c = { $ref: '$' } + a.d = new Buffer([0xde, 0xad]) + a.e = [ a, a.b ] + a.f = new Date() + a.g = /ab+a/i + + var a = clone(a); + + t.ok(a.b == a); + t.ok(a.c.$ref == '$') + t.ok(Buffer.isBuffer(a.d)) + t.ok(a.d[0] == 0xde) + t.ok(a.d[1] == 0xad) + t.ok(a.d.length == 2); + t.ok(Array.isArray(a.e)); + t.ok(a.e.length == 2); + t.ok(a.e[0] == a); + t.ok(a.e[1] == a.b); + t.ok(a.f instanceof Date); + t.ok(a.g instanceof RegExp); +}) + +test('serializing test', function (t) { + t.plan(14) + + var clone = require('../') + + var a = { } + a.b = a + a.c = { $ref: '$' } + a.d = new Buffer([0xde, 0xad]) + a.e = [ a, a.b ] + a.f = new Date() + a.g = /ab+a/i + + var buf = clone.serialize(a); + t.ok(buf.length, 'Buffer has length') + t.ok(Buffer.isBuffer(buf), 'Buffer has length') + + var a = clone.deserialize(buf); + + t.ok(a.b == a); + t.ok(a.c.$ref == '$') + t.ok(Buffer.isBuffer(a.d)) + t.ok(a.d[0] == 0xde) + t.ok(a.d[1] == 0xad) + t.ok(a.d.length == 2); + t.ok(Array.isArray(a.e)); + t.ok(a.e.length == 2); + t.ok(a.e[0] == a); + t.ok(a.e[1] == a.b); + t.ok(a.f instanceof Date); + t.ok(a.g instanceof RegExp); +}) + +test('deep copy root object', function (t) { + t.plan(3); + + var clone = require('../'); + + var buf = clone(new Buffer([0xca, 0xfe, 0xba, 0xbe])); + t.ok(Buffer.isBuffer(buf)); + t.ok(buf.length == 4); + t.ok(buf.readUInt32BE(0) == 0xcafebabe); +}); + +test('serializing root object', function (t) { + t.plan(3); + + var clone = require('../'); + + var buf = clone.deserialize(clone.serialize(new Buffer([0xca, 0xfe, 0xba, 0xbe]))); + t.ok(Buffer.isBuffer(buf)); + t.ok(buf.length == 4); + t.ok(buf.readUInt32BE(0) == 0xcafebabe); +}); + + +test('errors', function (t) { + t.plan(4); + + var clone = require('../'); + + var err = clone(new Error('boo!')); + t.ok(err instanceof Error); + t.ok(err.message == 'boo!'); + + var err = clone.deserialize(clone.serialize(new Error('boo!'))); + t.ok(err instanceof Error); + t.ok(err.message == 'boo!'); +}); \ No newline at end of file -- cgit v1.2.3