decocms 2.333.0 → 2.334.0

package/dist/server/node_modules/@protobufjs/eventemitter/README.md

@@ -0,0 +1,22 @@
+@protobufjs/eventemitter
+========================
+[![npm](https://img.shields.io/npm/v/@protobufjs/eventemitter.svg)](https://www.npmjs.com/package/@protobufjs/eventemitter)
+
+A minimal event emitter.
+
+API
+---
+
+* **new EventEmitter()**<br />
+  Constructs a new event emitter instance.
+
+* **EventEmitter#on(evt: `string`, fn: `function`, [ctx: `Object`]): `EventEmitter`**<br />
+  Registers an event listener.
+
+* **EventEmitter#off([evt: `string`], [fn: `function`]): `EventEmitter`**<br />
+  Removes an event listener or any matching listeners if arguments are omitted.
+
+* **EventEmitter#emit(evt: `string`, ...args: `*`): `EventEmitter`**<br />
+  Emits an event by calling its listeners with the specified arguments.
+
+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)

package/dist/server/node_modules/@protobufjs/eventemitter/index.d.ts

@@ -0,0 +1,43 @@
+export = EventEmitter;
+
+/**
+ * Constructs a new event emitter instance.
+ * @classdesc A minimal event emitter.
+ * @memberof util
+ * @constructor
+ */
+declare class EventEmitter {
+
+    /**
+     * Constructs a new event emitter instance.
+     * @classdesc A minimal event emitter.
+     * @memberof util
+     * @constructor
+     */
+    constructor();
+
+    /**
+     * Registers an event listener.
+     * @param {string} evt Event name
+     * @param {function} fn Listener
+     * @param {*} [ctx] Listener context
+     * @returns {util.EventEmitter} `this`
+     */
+    on(evt: string, fn: () => any, ctx?: any): EventEmitter;
+
+    /**
+     * Removes an event listener or any matching listeners if arguments are omitted.
+     * @param {string} [evt] Event name. Removes all listeners if omitted.
+     * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+     * @returns {util.EventEmitter} `this`
+     */
+    off(evt?: string, fn?: () => any): EventEmitter;
+
+    /**
+     * Emits an event by calling its listeners with the specified arguments.
+     * @param {string} evt Event name
+     * @param {...*} args Arguments
+     * @returns {util.EventEmitter} `this`
+     */
+    emit(evt: string, ...args: any[]): EventEmitter;
+}

package/dist/server/node_modules/@protobufjs/eventemitter/index.js

@@ -0,0 +1,76 @@
+"use strict";
+module.exports = EventEmitter;
+
+/**
+ * Constructs a new event emitter instance.
+ * @classdesc A minimal event emitter.
+ * @memberof util
+ * @constructor
+ */
+function EventEmitter() {
+
+    /**
+     * Registered listeners.
+     * @type {Object.<string,*>}
+     * @private
+     */
+    this._listeners = {};
+}
+
+/**
+ * Registers an event listener.
+ * @param {string} evt Event name
+ * @param {function} fn Listener
+ * @param {*} [ctx] Listener context
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.on = function on(evt, fn, ctx) {
+    (this._listeners[evt] || (this._listeners[evt] = [])).push({
+        fn  : fn,
+        ctx : ctx || this
+    });
+    return this;
+};
+
+/**
+ * Removes an event listener or any matching listeners if arguments are omitted.
+ * @param {string} [evt] Event name. Removes all listeners if omitted.
+ * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.off = function off(evt, fn) {
+    if (evt === undefined)
+        this._listeners = {};
+    else {
+        if (fn === undefined)
+            this._listeners[evt] = [];
+        else {
+            var listeners = this._listeners[evt];
+            for (var i = 0; i < listeners.length;)
+                if (listeners[i].fn === fn)
+                    listeners.splice(i, 1);
+                else
+                    ++i;
+        }
+    }
+    return this;
+};
+
+/**
+ * Emits an event by calling its listeners with the specified arguments.
+ * @param {string} evt Event name
+ * @param {...*} args Arguments
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.emit = function emit(evt) {
+    var listeners = this._listeners[evt];
+    if (listeners) {
+        var args = [],
+            i = 1;
+        for (; i < arguments.length;)
+            args.push(arguments[i++]);
+        for (i = 0; i < listeners.length;)
+            listeners[i].fn.apply(listeners[i++].ctx, args);
+    }
+    return this;
+};

package/dist/server/node_modules/@protobufjs/eventemitter/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@protobufjs/eventemitter",
+  "description": "A minimal event emitter.",
+  "version": "1.1.0",
+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dcodeIO/protobuf.js.git"
+  },
+  "license": "BSD-3-Clause",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "devDependencies": {
+    "istanbul": "^0.4.5",
+    "tape": "^4.6.3"
+  },
+  "scripts": {
+    "test": "tape tests/*.js",
+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
+  }
+}

package/dist/server/node_modules/@protobufjs/eventemitter/tests/index.js

@@ -0,0 +1,47 @@
+var tape = require("tape");
+
+var EventEmitter = require("..");
+
+tape.test("eventemitter", function(test) {
+
+    var ee = new EventEmitter();
+    var fn;
+    var ctx = {};
+
+    test.doesNotThrow(function() {
+        ee.emit("a", 1);
+        ee.off();
+        ee.off("a");
+        ee.off("a", function() {});
+    }, "should not throw if no listeners are registered");
+    
+    test.equal(ee.on("a", function(arg1) {
+        test.equal(this, ctx, "should be called with this = ctx");
+        test.equal(arg1, 1, "should be called with arg1 = 1");
+    }, ctx), ee, "should return itself when registering events");
+    ee.emit("a", 1);
+
+    ee.off("a");
+    test.same(ee._listeners, { a: [] }, "should remove all listeners of the respective event when calling off(evt)");
+
+    ee.off();
+    test.same(ee._listeners, {}, "should remove all listeners when just calling off()");
+
+    ee.on("a", fn = function(arg1) {
+        test.equal(this, ctx, "should be called with this = ctx");
+        test.equal(arg1, 1, "should be called with arg1 = 1");
+    }, ctx).emit("a", 1);
+
+    ee.off("a", fn);
+    test.same(ee._listeners, { a: [] }, "should remove the exact listener when calling off(evt, fn)");
+
+    ee.on("a", function() {
+        test.equal(this, ee, "should be called with this = ee");
+    }).emit("a");
+
+    test.doesNotThrow(function() {
+        ee.off("a", fn);
+    }, "should not throw if no such listener is found");
+
+    test.end();
+});

package/dist/server/node_modules/@protobufjs/float/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of its author, nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/dist/server/node_modules/@protobufjs/float/README.md

@@ -0,0 +1,102 @@
+@protobufjs/float
+=================
+[![npm](https://img.shields.io/npm/v/@protobufjs/float.svg)](https://www.npmjs.com/package/@protobufjs/float)
+
+Reads / writes floats / doubles from / to buffers in both modern and ancient browsers. Fast.
+
+API
+---
+
+* **writeFloatLE(val: `number`, buf: `Uint8Array`, pos: `number`)**<br />
+  Writes a 32 bit float to a buffer using little endian byte order.
+
+* **writeFloatBE(val: `number`, buf: `Uint8Array`, pos: `number`)**<br />
+  Writes a 32 bit float to a buffer using big endian byte order.
+
+* **readFloatLE(buf: `Uint8Array`, pos: `number`): `number`**<br />
+  Reads a 32 bit float from a buffer using little endian byte order.
+
+* **readFloatBE(buf: `Uint8Array`, pos: `number`): `number`**<br />
+  Reads a 32 bit float from a buffer using big endian byte order.
+
+* **writeDoubleLE(val: `number`, buf: `Uint8Array`, pos: `number`)**<br />
+  Writes a 64 bit double to a buffer using little endian byte order.
+
+* **writeDoubleBE(val: `number`, buf: `Uint8Array`, pos: `number`)**<br />
+  Writes a 64 bit double to a buffer using big endian byte order.
+
+* **readDoubleLE(buf: `Uint8Array`, pos: `number`): `number`**<br />
+  Reads a 64 bit double from a buffer using little endian byte order.
+
+* **readDoubleBE(buf: `Uint8Array`, pos: `number`): `number`**<br />
+  Reads a 64 bit double from a buffer using big endian byte order.
+
+Performance
+-----------
+There is a simple benchmark included comparing raw read/write performance of this library (float), float's fallback for old browsers, the [ieee754](https://www.npmjs.com/package/ieee754) module and node's [buffer](https://nodejs.org/api/buffer.html). On an i7-2600k running node 6.9.1 it yields:
+
+```
+benchmarking writeFloat performance ...
+
+float x 42,741,625 ops/sec ±1.75% (81 runs sampled)
+float (fallback) x 11,272,532 ops/sec ±1.12% (85 runs sampled)
+ieee754 x 8,653,337 ops/sec ±1.18% (84 runs sampled)
+buffer x 12,412,414 ops/sec ±1.41% (83 runs sampled)
+buffer (noAssert) x 13,471,149 ops/sec ±1.09% (84 runs sampled)
+
+                      float was fastest
+           float (fallback) was 73.5% slower
+                    ieee754 was 79.6% slower
+                     buffer was 70.9% slower
+          buffer (noAssert) was 68.3% slower
+
+benchmarking readFloat performance ...
+
+float x 44,382,729 ops/sec ±1.70% (84 runs sampled)
+float (fallback) x 20,925,938 ops/sec ±0.86% (87 runs sampled)
+ieee754 x 17,189,009 ops/sec ±1.01% (87 runs sampled)
+buffer x 10,518,437 ops/sec ±1.04% (83 runs sampled)
+buffer (noAssert) x 11,031,636 ops/sec ±1.15% (87 runs sampled)
+
+                      float was fastest
+           float (fallback) was 52.5% slower
+                    ieee754 was 61.0% slower
+                     buffer was 76.1% slower
+          buffer (noAssert) was 75.0% slower
+
+benchmarking writeDouble performance ...
+
+float x 38,624,906 ops/sec ±0.93% (83 runs sampled)
+float (fallback) x 10,457,811 ops/sec ±1.54% (85 runs sampled)
+ieee754 x 7,681,130 ops/sec ±1.11% (83 runs sampled)
+buffer x 12,657,876 ops/sec ±1.03% (83 runs sampled)
+buffer (noAssert) x 13,372,795 ops/sec ±0.84% (85 runs sampled)
+
+                      float was fastest
+           float (fallback) was 73.1% slower
+                    ieee754 was 80.1% slower
+                     buffer was 67.3% slower
+          buffer (noAssert) was 65.3% slower
+
+benchmarking readDouble performance ...
+
+float x 40,527,888 ops/sec ±1.05% (84 runs sampled)
+float (fallback) x 18,696,480 ops/sec ±0.84% (86 runs sampled)
+ieee754 x 14,074,028 ops/sec ±1.04% (87 runs sampled)
+buffer x 10,092,367 ops/sec ±1.15% (84 runs sampled)
+buffer (noAssert) x 10,623,793 ops/sec ±0.96% (84 runs sampled)
+
+                      float was fastest
+           float (fallback) was 53.8% slower
+                    ieee754 was 65.3% slower
+                     buffer was 75.1% slower
+          buffer (noAssert) was 73.8% slower
+```
+
+To run it yourself:
+
+```
+$> npm run bench
+```
+
+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)

package/dist/server/node_modules/@protobufjs/float/bench/index.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var float = require(".."),
+    ieee754 = require("ieee754"),
+    newSuite = require("./suite");
+
+var F32 = Float32Array;
+var F64 = Float64Array;
+delete global.Float32Array;
+delete global.Float64Array;
+var floatFallback = float({});
+global.Float32Array = F32;
+global.Float64Array = F64;
+
+var buf = new Buffer(8);
+
+newSuite("writeFloat")
+.add("float", function() {
+    float.writeFloatLE(0.1, buf, 0);
+})
+.add("float (fallback)", function() {
+    floatFallback.writeFloatLE(0.1, buf, 0);
+})
+.add("ieee754", function() {
+    ieee754.write(buf, 0.1, 0, true, 23, 4);
+})
+.add("buffer", function() {
+    buf.writeFloatLE(0.1, 0);
+})
+.add("buffer (noAssert)", function() {
+    buf.writeFloatLE(0.1, 0, true);
+})
+.run();
+
+newSuite("readFloat")
+.add("float", function() {
+    float.readFloatLE(buf, 0);
+})
+.add("float (fallback)", function() {
+    floatFallback.readFloatLE(buf, 0);
+})
+.add("ieee754", function() {
+    ieee754.read(buf, 0, true, 23, 4);
+})
+.add("buffer", function() {
+    buf.readFloatLE(0);
+})
+.add("buffer (noAssert)", function() {
+    buf.readFloatLE(0, true);
+})
+.run();
+
+newSuite("writeDouble")
+.add("float", function() {
+    float.writeDoubleLE(0.1, buf, 0);
+})
+.add("float (fallback)", function() {
+    floatFallback.writeDoubleLE(0.1, buf, 0);
+})
+.add("ieee754", function() {
+    ieee754.write(buf, 0.1, 0, true, 52, 8);
+})
+.add("buffer", function() {
+    buf.writeDoubleLE(0.1, 0);
+})
+.add("buffer (noAssert)", function() {
+    buf.writeDoubleLE(0.1, 0, true);
+})
+.run();
+
+newSuite("readDouble")
+.add("float", function() {
+    float.readDoubleLE(buf, 0);
+})
+.add("float (fallback)", function() {
+    floatFallback.readDoubleLE(buf, 0);
+})
+.add("ieee754", function() {
+    ieee754.read(buf, 0, true, 52, 8);
+})
+.add("buffer", function() {
+    buf.readDoubleLE(0);
+})
+.add("buffer (noAssert)", function() {
+    buf.readDoubleLE(0, true);
+})
+.run();

package/dist/server/node_modules/@protobufjs/float/bench/suite.js

@@ -0,0 +1,46 @@
+"use strict";
+module.exports = newSuite;
+
+var benchmark = require("benchmark"),
+    chalk     = require("chalk");
+
+var padSize = 27;
+
+function newSuite(name) {
+    var benches = [];
+    return new benchmark.Suite(name)
+    .on("add", function(event) {
+        benches.push(event.target);
+    })
+    .on("start", function() {
+        process.stdout.write("benchmarking " + name + " performance ...\n\n");
+    })
+    .on("cycle", function(event) {
+        process.stdout.write(String(event.target) + "\n");
+    })
+    .on("complete", function() {
+        if (benches.length > 1) {
+            var fastest = this.filter("fastest"), // eslint-disable-line no-invalid-this
+                fastestHz = getHz(fastest[0]);
+            process.stdout.write("\n" + chalk.white(pad(fastest[0].name, padSize)) + " was " + chalk.green("fastest") + "\n");
+            benches.forEach(function(bench) {
+                if (fastest.indexOf(bench) === 0)
+                    return;
+                var hz = hz = getHz(bench);
+                var percent = (1 - hz / fastestHz) * 100;
+                process.stdout.write(chalk.white(pad(bench.name, padSize)) + " was " + chalk.red(percent.toFixed(1) + "% slower") + "\n");
+            });
+        }
+        process.stdout.write("\n");
+    });
+}
+
+function getHz(bench) {
+    return 1 / (bench.stats.mean + bench.stats.moe);
+}
+
+function pad(str, len, l) {
+    while (str.length < len)
+        str = l ? str + " " : " " + str;
+    return str;
+}

package/dist/server/node_modules/@protobufjs/float/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Writes a 32 bit float to a buffer using little endian byte order.
+ * @name writeFloatLE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+export function writeFloatLE(val: number, buf: Uint8Array, pos: number): void;
+
+/**
+ * Writes a 32 bit float to a buffer using big endian byte order.
+ * @name writeFloatBE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+export function writeFloatBE(val: number, buf: Uint8Array, pos: number): void;
+
+/**
+ * Reads a 32 bit float from a buffer using little endian byte order.
+ * @name readFloatLE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+export function readFloatLE(buf: Uint8Array, pos: number): number;
+
+/**
+ * Reads a 32 bit float from a buffer using big endian byte order.
+ * @name readFloatBE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+export function readFloatBE(buf: Uint8Array, pos: number): number;
+
+/**
+ * Writes a 64 bit double to a buffer using little endian byte order.
+ * @name writeDoubleLE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+export function writeDoubleLE(val: number, buf: Uint8Array, pos: number): void;
+
+/**
+ * Writes a 64 bit double to a buffer using big endian byte order.
+ * @name writeDoubleBE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+export function writeDoubleBE(val: number, buf: Uint8Array, pos: number): void;
+
+/**
+ * Reads a 64 bit double from a buffer using little endian byte order.
+ * @name readDoubleLE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+export function readDoubleLE(buf: Uint8Array, pos: number): number;
+
+/**
+ * Reads a 64 bit double from a buffer using big endian byte order.
+ * @name readDoubleBE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+export function readDoubleBE(buf: Uint8Array, pos: number): number;