decocms 2.371.0 → 2.371.1

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

@@ -0,0 +1,100 @@
+var tape = require("tape");
+
+var float = require("..");
+
+tape.test("float", function(test) {
+
+    // default
+    test.test(test.name + " - typed array", function(test) {
+        runTest(float, test);
+    });
+
+    // ieee754
+    test.test(test.name + " - fallback", function(test) {
+        var F32 = global.Float32Array,
+            F64 = global.Float64Array;
+        delete global.Float32Array;
+        delete global.Float64Array;
+        runTest(float({}), test);
+        global.Float32Array = F32;
+        global.Float64Array = F64;
+    });
+});
+
+function runTest(float, test) {
+
+    var common = [
+        0,
+        -0,
+        Infinity,
+        -Infinity,
+        0.125,
+        1024.5,
+        -4096.5,
+        NaN
+    ];
+
+    test.test(test.name + " - using 32 bits", function(test) {
+        common.concat([
+            3.4028234663852886e+38,
+            1.1754943508222875e-38,
+            1.1754946310819804e-39
+        ])
+        .forEach(function(value) {
+            var strval = value === 0 && 1 / value < 0 ? "-0" : value.toString();
+            test.ok(
+                checkValue(value, 4, float.readFloatLE, float.writeFloatLE, Buffer.prototype.writeFloatLE),
+                "should write and read back " + strval + " (32 bit LE)"
+            );
+            test.ok(
+                checkValue(value, 4, float.readFloatBE, float.writeFloatBE, Buffer.prototype.writeFloatBE),
+                "should write and read back " + strval + " (32 bit BE)"
+            );
+        });
+        test.end();
+    });
+
+    test.test(test.name + " - using 64 bits", function(test) {
+        common.concat([
+            1.7976931348623157e+308,
+            2.2250738585072014e-308,
+            2.2250738585072014e-309
+        ])
+        .forEach(function(value) {
+            var strval = value === 0 && 1 / value < 0 ? "-0" : value.toString();
+            test.ok(
+                checkValue(value, 8, float.readDoubleLE, float.writeDoubleLE, Buffer.prototype.writeDoubleLE),
+                "should write and read back " + strval + " (64 bit LE)"
+            );
+            test.ok(
+                checkValue(value, 8, float.readDoubleBE, float.writeDoubleBE, Buffer.prototype.writeDoubleBE),
+                "should write and read back " + strval + " (64 bit BE)"
+            );
+        });
+        test.end();
+    });
+
+    test.end();
+}
+
+function checkValue(value, size, read, write, write_comp) {
+    var buffer = new Buffer(size);
+    write(value, buffer, 0);
+    var value_comp = read(buffer, 0);
+    var strval = value === 0 && 1 / value < 0 ? "-0" : value.toString();
+    if (value !== value) {
+        if (value_comp === value_comp)
+            return false;
+    } else if (value_comp !== value)
+        return false;
+
+    var buffer_comp = new Buffer(size);
+    write_comp.call(buffer_comp, value, 0);
+    for (var i = 0; i < size; ++i)
+        if (buffer[i] !== buffer_comp[i]) {
+            console.error(">", buffer, buffer_comp);
+            return false;
+        }
+
+    return true;
+}

package/dist/server/node_modules/@protobufjs/inquire/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/inquire/README.md

@@ -0,0 +1,13 @@
+@protobufjs/inquire
+===================
+[![npm](https://img.shields.io/npm/v/@protobufjs/inquire.svg)](https://www.npmjs.com/package/@protobufjs/inquire)
+
+Requires a module only if available and hides the require call from bundlers.
+
+API
+---
+
+* **inquire(moduleName: `string`): `?Object`**<br />
+  Requires a module only if available.
+
+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)

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

@@ -0,0 +1,9 @@
+export = inquire;
+
+/**
+ * Requires a module only if available.
+ * @memberof util
+ * @param {string} moduleName Module to require
+ * @returns {?Object} Required module if available and not empty, otherwise `null`
+ */
+declare function inquire(moduleName: string): object;

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

@@ -0,0 +1,37 @@
+"use strict";
+module.exports = inquire;
+
+/**
+ * Requires a module only if available.
+ * @memberof util
+ * @param {string} moduleName Module to require
+ * @returns {?Object} Required module if available and not empty, otherwise `null`
+ */
+function inquire(moduleName) {
+  try {
+    if (typeof require !== "function") {
+      return null;
+    }
+    var mod = require(moduleName);
+    if (mod && (mod.length || Object.keys(mod).length)) return mod;
+    return null;
+  } catch (err) {
+    // ignore
+    return null;
+  }
+}
+
+/*
+// maybe worth a shot to prevent renaming issues:
+// see: https://github.com/webpack/webpack/blob/master/lib/dependencies/CommonJsRequireDependencyParserPlugin.js
+// triggers on:
+// - expression require.cache
+// - expression require (???)
+// - call require
+// - call require:commonjs:item
+// - call require:commonjs:context
+
+Object.defineProperty(Function.prototype, "__self", { get: function() { return this; } });
+var r = require.__self;
+delete Function.prototype.__self;
+*/

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

@@ -0,0 +1,21 @@
+{
+  "name": "@protobufjs/inquire",
+  "description": "Requires a module only if available and hides the require call from bundlers.",
+  "version": "1.1.1",
+  "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": "^5.0.0"
+  },
+  "scripts": {
+    "test": "tape tests/*.js",
+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
+  }
+}

package/dist/server/node_modules/@protobufjs/inquire/tests/data/array.js

@@ -0,0 +1 @@
+module.exports = [1];

package/dist/server/node_modules/@protobufjs/inquire/tests/data/emptyArray.js

@@ -0,0 +1 @@
+module.exports = [];

package/dist/server/node_modules/@protobufjs/inquire/tests/data/emptyObject.js

@@ -0,0 +1 @@
+module.exports = {};

package/dist/server/node_modules/@protobufjs/inquire/tests/data/object.js

@@ -0,0 +1 @@
+module.exports = { a: 1 };

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

@@ -0,0 +1,20 @@
+var tape = require("tape");
+
+var inquire = require("..");
+
+tape.test("inquire", function(test) {
+
+    test.equal(inquire("buffer").Buffer, Buffer, "should be able to require \"buffer\"");
+
+    test.equal(inquire("%invalid"), null, "should not be able to require \"%invalid\"");
+
+    test.equal(inquire("./tests/data/emptyObject"), null, "should return null when requiring a module exporting an empty object");
+
+    test.equal(inquire("./tests/data/emptyArray"), null, "should return null when requiring a module exporting an empty array");
+
+    test.same(inquire("./tests/data/object"), { a: 1 }, "should return the object if a non-empty object");
+
+    test.same(inquire("./tests/data/array"), [ 1 ], "should return the module if a non-empty array");
+
+    test.end();
+});

package/dist/server/node_modules/@protobufjs/pool/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/pool/README.md

@@ -0,0 +1,13 @@
+@protobufjs/pool
+================
+[![npm](https://img.shields.io/npm/v/@protobufjs/pool.svg)](https://www.npmjs.com/package/@protobufjs/pool)
+
+A general purpose buffer pool.
+
+API
+---
+
+* **pool(alloc: `function(size: number): Uint8Array`, slice: `function(this: Uint8Array, start: number, end: number): Uint8Array`, [size=8192: `number`]): `function(size: number): Uint8Array`**<br />
+  Creates a pooled allocator.
+
+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)

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

@@ -0,0 +1,32 @@
+export = pool;
+
+/**
+ * An allocator as used by {@link util.pool}.
+ * @typedef PoolAllocator
+ * @type {function}
+ * @param {number} size Buffer size
+ * @returns {Uint8Array} Buffer
+ */
+type PoolAllocator = (size: number) => Uint8Array;
+
+/**
+ * A slicer as used by {@link util.pool}.
+ * @typedef PoolSlicer
+ * @type {function}
+ * @param {number} start Start offset
+ * @param {number} end End offset
+ * @returns {Uint8Array} Buffer slice
+ * @this {Uint8Array}
+ */
+type PoolSlicer = (this: Uint8Array, start: number, end: number) => Uint8Array;
+
+/**
+ * A general purpose buffer pool.
+ * @memberof util
+ * @function
+ * @param {PoolAllocator} alloc Allocator
+ * @param {PoolSlicer} slice Slicer
+ * @param {number} [size=8192] Slab size
+ * @returns {PoolAllocator} Pooled allocator
+ */
+declare function pool(alloc: PoolAllocator, slice: PoolSlicer, size?: number): PoolAllocator;

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

@@ -0,0 +1,48 @@
+"use strict";
+module.exports = pool;
+
+/**
+ * An allocator as used by {@link util.pool}.
+ * @typedef PoolAllocator
+ * @type {function}
+ * @param {number} size Buffer size
+ * @returns {Uint8Array} Buffer
+ */
+
+/**
+ * A slicer as used by {@link util.pool}.
+ * @typedef PoolSlicer
+ * @type {function}
+ * @param {number} start Start offset
+ * @param {number} end End offset
+ * @returns {Uint8Array} Buffer slice
+ * @this {Uint8Array}
+ */
+
+/**
+ * A general purpose buffer pool.
+ * @memberof util
+ * @function
+ * @param {PoolAllocator} alloc Allocator
+ * @param {PoolSlicer} slice Slicer
+ * @param {number} [size=8192] Slab size
+ * @returns {PoolAllocator} Pooled allocator
+ */
+function pool(alloc, slice, size) {
+    var SIZE   = size || 8192;
+    var MAX    = SIZE >>> 1;
+    var slab   = null;
+    var offset = SIZE;
+    return function pool_alloc(size) {
+        if (size < 1 || size > MAX)
+            return alloc(size);
+        if (offset + size > SIZE) {
+            slab = alloc(SIZE);
+            offset = 0;
+        }
+        var buf = slice.call(slab, offset, offset += size);
+        if (offset & 7) // align to 32 bit
+            offset = (offset | 7) + 1;
+        return buf;
+    };
+}

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

@@ -0,0 +1,21 @@
+{
+  "name": "@protobufjs/pool",
+  "description": "A general purpose buffer pool.",
+  "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/pool/tests/index.js

@@ -0,0 +1,33 @@
+var tape = require("tape");
+
+var pool = require("..");
+
+if (typeof Uint8Array !== "undefined")
+tape.test("pool", function(test) {
+
+    var alloc = pool(function(size) { return new Uint8Array(size); }, Uint8Array.prototype.subarray);
+
+    var buf1 = alloc(0);
+    test.equal(buf1.length, 0, "should allocate a buffer of size 0");
+
+    var buf2 = alloc(1);
+    test.equal(buf2.length, 1, "should allocate a buffer of size 1 (initializes slab)");
+
+    test.notEqual(buf2.buffer, buf1.buffer, "should not reference the same backing buffer if previous buffer had size 0");
+    test.equal(buf2.byteOffset, 0, "should allocate at byteOffset 0 when using a new slab");
+
+    buf1 = alloc(1);
+    test.equal(buf1.buffer, buf2.buffer, "should reference the same backing buffer when allocating a chunk fitting into the slab");
+    test.equal(buf1.byteOffset, 8, "should align slices to 32 bit and this allocate at byteOffset 8");
+
+    var buf3 = alloc(4097);
+    test.notEqual(buf3.buffer, buf2.buffer, "should not reference the same backing buffer when allocating a buffer larger than half the backing buffer's size");
+
+    buf2 = alloc(4096);
+    test.equal(buf2.buffer, buf1.buffer, "should reference the same backing buffer when allocating a buffer smaller or equal than half the backing buffer's size");
+
+    buf1 = alloc(4096);
+    test.notEqual(buf1.buffer, buf2.buffer, "should not reference the same backing buffer when the slab is exhausted (initializes new slab)");
+
+    test.end();
+});

package/dist/server/node_modules/@protobufjs/utf8/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/utf8/README.md

@@ -0,0 +1,20 @@
+@protobufjs/utf8
+================
+[![npm](https://img.shields.io/npm/v/@protobufjs/utf8.svg)](https://www.npmjs.com/package/@protobufjs/utf8)
+
+A minimal UTF8 implementation for number arrays.
+
+API
+---
+
+* **utf8.length(string: `string`): `number`**<br />
+  Calculates the UTF8 byte length of a string.
+
+* **utf8.read(buffer: `Uint8Array`, start: `number`, end: `number`): `string`**<br />
+  Reads UTF8 bytes as a string.
+
+* **utf8.write(string: `string`, buffer: `Uint8Array`, offset: `number`): `number`**<br />
+  Writes a string as UTF8 bytes.
+
+
+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)

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

@@ -0,0 +1,24 @@
+/**
+ * Calculates the UTF8 byte length of a string.
+ * @param {string} string String
+ * @returns {number} Byte length
+ */
+export function length(string: string): number;
+
+/**
+ * Reads UTF8 bytes as a string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} String read
+ */
+export function read(buffer: Uint8Array, start: number, end: number): string;
+
+/**
+ * Writes a string as UTF8 bytes.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Bytes written
+ */
+export function write(string: string, buffer: Uint8Array, offset: number): number;

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

@@ -0,0 +1,104 @@
+"use strict";
+
+/**
+ * A minimal UTF8 implementation for number arrays.
+ * @memberof util
+ * @namespace
+ */
+var utf8 = exports,
+    replacementChar = "\ufffd";
+
+/**
+ * Calculates the UTF8 byte length of a string.
+ * @param {string} string String
+ * @returns {number} Byte length
+ */
+utf8.length = function utf8_length(string) {
+    var len = 0,
+        c = 0;
+    for (var i = 0; i < string.length; ++i) {
+        c = string.charCodeAt(i);
+        if (c < 128)
+            len += 1;
+        else if (c < 2048)
+            len += 2;
+        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
+            ++i;
+            len += 4;
+        } else
+            len += 3;
+    }
+    return len;
+};
+
+/**
+ * Reads UTF8 bytes as a string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} String read
+ */
+utf8.read = function utf8_read(buffer, start, end) {
+    if (end - start < 1) {
+        return "";
+    }
+
+    var str = "";
+    for (var i = start; i < end;) {
+        var t = buffer[i++];
+        if (t <= 0x7F) {
+            str += String.fromCharCode(t);
+        } else if (t >= 0xC0 && t < 0xE0) {
+            var c2 = (t & 0x1F) << 6 | buffer[i++] & 0x3F;
+            str += c2 >= 0x80 ? String.fromCharCode(c2) : replacementChar;
+        } else if (t >= 0xE0 && t < 0xF0) {
+            var c3 = (t & 0xF) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;
+            str += c3 >= 0x800 ? String.fromCharCode(c3) : replacementChar;
+        } else if (t >= 0xF0) {
+            var t2 = (t & 7) << 18 | (buffer[i++] & 0x3F) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;
+            if (t2 < 0x10000 || t2 > 0x10FFFF)
+                str += replacementChar;
+            else {
+                t2 -= 0x10000;
+                str += String.fromCharCode(0xD800 + (t2 >> 10));
+                str += String.fromCharCode(0xDC00 + (t2 & 0x3FF));
+            }
+        }
+    }
+
+    return str;
+};
+
+/**
+ * Writes a string as UTF8 bytes.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Bytes written
+ */
+utf8.write = function utf8_write(string, buffer, offset) {
+    var start = offset,
+        c1, // character 1
+        c2; // character 2
+    for (var i = 0; i < string.length; ++i) {
+        c1 = string.charCodeAt(i);
+        if (c1 < 128) {
+            buffer[offset++] = c1;
+        } else if (c1 < 2048) {
+            buffer[offset++] = c1 >> 6       | 192;
+            buffer[offset++] = c1       & 63 | 128;
+        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
+            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
+            ++i;
+            buffer[offset++] = c1 >> 18      | 240;
+            buffer[offset++] = c1 >> 12 & 63 | 128;
+            buffer[offset++] = c1 >> 6  & 63 | 128;
+            buffer[offset++] = c1       & 63 | 128;
+        } else {
+            buffer[offset++] = c1 >> 12      | 224;
+            buffer[offset++] = c1 >> 6  & 63 | 128;
+            buffer[offset++] = c1       & 63 | 128;
+        }
+    }
+    return offset - start;
+};

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

@@ -0,0 +1,21 @@
+{
+  "name": "@protobufjs/utf8",
+  "description": "A minimal UTF8 implementation for number arrays.",
+  "version": "1.1.1",
+  "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": "^5.0.0"
+  },
+  "scripts": {
+    "test": "tape tests/*.js",
+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
+  }
+}