From a4496549549a655891f29273973774fb39c486db Mon Sep 17 00:00:00 2001 From: Tim Brown Date: Wed, 2 Dec 2020 13:41:31 -0500 Subject: [PATCH] Add protobuf dependency and generate types * Add https://github.com/protobufjs/protobuf.js in order to serialize and deserialize DDSketch objects as protobufs, so that they can efficientlly be transferred over a network * Check in `proto/DDSketch.proto` definition, and add a new build command `yarn generate:proto` that reads this definition, and generates the JavaScript and TypeScript blobs (`proto/compiled.{js|d.ts}`) necessary to interact with protobufs --- .eslintignore | 2 + package.json | 6 +- src/ddsketch/proto/DDSketch.proto | 64 +++ src/ddsketch/proto/compiled.d.ts | 323 ++++++++++++ src/ddsketch/proto/compiled.js | 849 ++++++++++++++++++++++++++++++ yarn.lock | 87 +++ 6 files changed, 1329 insertions(+), 2 deletions(-) create mode 100644 src/ddsketch/proto/DDSketch.proto create mode 100644 src/ddsketch/proto/compiled.d.ts create mode 100644 src/ddsketch/proto/compiled.js diff --git a/.eslintignore b/.eslintignore index f06235c..0dc2f6b 100644 --- a/.eslintignore +++ b/.eslintignore @@ -1,2 +1,4 @@ node_modules dist +src/ddsketch/proto/compiled.js +src/ddsketch/proto/compiled.d.ts diff --git a/package.json b/package.json index aa5131b..d5283d6 100644 --- a/package.json +++ b/package.json @@ -11,11 +11,13 @@ "build": "tsc -p tsconfig.build.json", "test": "jest", "lint": "eslint src/**/*", - "typecheck": "tsc --noEmit" + "typecheck": "tsc --noEmit", + "generate:proto": "pbjs -t static-module -w commonjs -o src/ddsketch/proto/compiled.js src/ddsketch/proto/DDSketch.proto && pbts -o src/ddsketch/proto/compiled.d.ts src/ddsketch/proto/compiled.js" }, "dependencies": { "math-float64-frexp": "^1.0.0", - "math-float64-ldexp": "^1.0.1" + "math-float64-ldexp": "^1.0.1", + "protobufjs": "^6.10.2" }, "devDependencies": { "@types/jest": "^26.0.14", diff --git a/src/ddsketch/proto/DDSketch.proto b/src/ddsketch/proto/DDSketch.proto new file mode 100644 index 0000000..3b4d266 --- /dev/null +++ b/src/ddsketch/proto/DDSketch.proto @@ -0,0 +1,64 @@ +/* Unless explicitly stated otherwise all files in this repository are licensed under the Apache License 2.0. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2020 Datadog, Inc. + */ + +syntax = "proto3"; + +// A DDSketch is essentially a histogram that partitions the range of positive values into an infinite number of +// indexed bins whose size grows exponentially. It keeps track of the number of values (or possibly floating-point +// weights) added to each bin. Negative values are partitioned like positive values, symmetrically to zero. +// The value zero as well as its close neighborhood that would be mapped to extreme bin indexes is mapped to a specific +// counter. +message DDSketch { + // The mapping between positive values and the bin indexes they belong to. + IndexMapping mapping = 1; + + // The store for keeping track of positive values. + Store positiveValues = 2; + + // The store for keeping track of negative values. A negative value v is mapped using its positive opposite -v. + Store negativeValues = 3; + + // The count for the value zero and its close neighborhood (whose width depends on the mapping). + double zeroCount = 4; +} + +// How to map positive values to the bins they belong to. +message IndexMapping { + // The gamma parameter of the mapping, such that bin index that a value v belongs to is roughly equal to + // log(v)/log(gamma). + double gamma = 1; + + // An offset that can be used to shift all bin indexes. + double indexOffset = 2; + + // To speed up the computation of the index a value belongs to, the computation of the log may be approximated using + // the fact that the log to the base 2 of powers of 2 can be computed at a low cost from the binary representation of + // the input value. Other values can be approximated by interpolating between successive powers of 2 (linearly, + // quadratically or cubically). + // NONE means that the log is to be computed exactly (no interpolation). + Interpolation interpolation = 3; + enum Interpolation { + NONE = 0; + LINEAR = 1; + QUADRATIC = 2; + CUBIC = 3; + } +} + +// A Store maps bin indexes to their respective counts. +// Counts can be encoded sparsely using binCounts, but also in a contiguous way using contiguousBinCounts and +// contiguousBinIndexOffset. Given that non-empty bins are in practice usually contiguous or close to one another, the +// latter contiguous encoding method is usually more efficient than the sparse one. +// Both encoding methods can be used conjointly. If a bin appears in both the sparse and the contiguous encodings, its +// count value is the sum of the counts in each encodings. +message Store { + // The bin counts, encoded sparsely. + map binCounts = 1; + + // The bin counts, encoded contiguously. The values of contiguousBinCounts are the counts for the bins of indexes + // o, o+1, o+2, etc., where o is contiguousBinIndexOffset. + repeated double contiguousBinCounts = 2 [packed = true]; + sint32 contiguousBinIndexOffset = 3; +} diff --git a/src/ddsketch/proto/compiled.d.ts b/src/ddsketch/proto/compiled.d.ts new file mode 100644 index 0000000..318ff70 --- /dev/null +++ b/src/ddsketch/proto/compiled.d.ts @@ -0,0 +1,323 @@ +import * as $protobuf from "protobufjs"; +/** Properties of a DDSketch. */ +export interface IDDSketch { + + /** DDSketch mapping */ + mapping?: (IIndexMapping|null); + + /** DDSketch positiveValues */ + positiveValues?: (IStore|null); + + /** DDSketch negativeValues */ + negativeValues?: (IStore|null); + + /** DDSketch zeroCount */ + zeroCount?: (number|null); +} + +/** Represents a DDSketch. */ +export class DDSketch implements IDDSketch { + + /** + * Constructs a new DDSketch. + * @param [properties] Properties to set + */ + constructor(properties?: IDDSketch); + + /** DDSketch mapping. */ + public mapping?: (IIndexMapping|null); + + /** DDSketch positiveValues. */ + public positiveValues?: (IStore|null); + + /** DDSketch negativeValues. */ + public negativeValues?: (IStore|null); + + /** DDSketch zeroCount. */ + public zeroCount: number; + + /** + * Creates a new DDSketch instance using the specified properties. + * @param [properties] Properties to set + * @returns DDSketch instance + */ + public static create(properties?: IDDSketch): DDSketch; + + /** + * Encodes the specified DDSketch message. Does not implicitly {@link DDSketch.verify|verify} messages. + * @param message DDSketch message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: IDDSketch, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified DDSketch message, length delimited. Does not implicitly {@link DDSketch.verify|verify} messages. + * @param message DDSketch message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: IDDSketch, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DDSketch message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns DDSketch + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): DDSketch; + + /** + * Decodes a DDSketch message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns DDSketch + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): DDSketch; + + /** + * Verifies a DDSketch message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a DDSketch message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns DDSketch + */ + public static fromObject(object: { [k: string]: any }): DDSketch; + + /** + * Creates a plain object from a DDSketch message. Also converts values to other types if specified. + * @param message DDSketch + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: DDSketch, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this DDSketch to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +/** Properties of an IndexMapping. */ +export interface IIndexMapping { + + /** IndexMapping gamma */ + gamma?: (number|null); + + /** IndexMapping indexOffset */ + indexOffset?: (number|null); + + /** IndexMapping interpolation */ + interpolation?: (IndexMapping.Interpolation|null); +} + +/** Represents an IndexMapping. */ +export class IndexMapping implements IIndexMapping { + + /** + * Constructs a new IndexMapping. + * @param [properties] Properties to set + */ + constructor(properties?: IIndexMapping); + + /** IndexMapping gamma. */ + public gamma: number; + + /** IndexMapping indexOffset. */ + public indexOffset: number; + + /** IndexMapping interpolation. */ + public interpolation: IndexMapping.Interpolation; + + /** + * Creates a new IndexMapping instance using the specified properties. + * @param [properties] Properties to set + * @returns IndexMapping instance + */ + public static create(properties?: IIndexMapping): IndexMapping; + + /** + * Encodes the specified IndexMapping message. Does not implicitly {@link IndexMapping.verify|verify} messages. + * @param message IndexMapping message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: IIndexMapping, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified IndexMapping message, length delimited. Does not implicitly {@link IndexMapping.verify|verify} messages. + * @param message IndexMapping message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: IIndexMapping, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an IndexMapping message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns IndexMapping + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): IndexMapping; + + /** + * Decodes an IndexMapping message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns IndexMapping + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): IndexMapping; + + /** + * Verifies an IndexMapping message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates an IndexMapping message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns IndexMapping + */ + public static fromObject(object: { [k: string]: any }): IndexMapping; + + /** + * Creates a plain object from an IndexMapping message. Also converts values to other types if specified. + * @param message IndexMapping + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: IndexMapping, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this IndexMapping to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} + +export namespace IndexMapping { + + /** Interpolation enum. */ + enum Interpolation { + NONE = 0, + LINEAR = 1, + QUADRATIC = 2, + CUBIC = 3 + } +} + +/** Properties of a Store. */ +export interface IStore { + + /** Store binCounts */ + binCounts?: ({ [k: string]: number }|null); + + /** Store contiguousBinCounts */ + contiguousBinCounts?: (number[]|null); + + /** Store contiguousBinIndexOffset */ + contiguousBinIndexOffset?: (number|null); +} + +/** Represents a Store. */ +export class Store implements IStore { + + /** + * Constructs a new Store. + * @param [properties] Properties to set + */ + constructor(properties?: IStore); + + /** Store binCounts. */ + public binCounts: { [k: string]: number }; + + /** Store contiguousBinCounts. */ + public contiguousBinCounts: number[]; + + /** Store contiguousBinIndexOffset. */ + public contiguousBinIndexOffset: number; + + /** + * Creates a new Store instance using the specified properties. + * @param [properties] Properties to set + * @returns Store instance + */ + public static create(properties?: IStore): Store; + + /** + * Encodes the specified Store message. Does not implicitly {@link Store.verify|verify} messages. + * @param message Store message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: IStore, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified Store message, length delimited. Does not implicitly {@link Store.verify|verify} messages. + * @param message Store message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: IStore, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Store message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns Store + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): Store; + + /** + * Decodes a Store message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns Store + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): Store; + + /** + * Verifies a Store message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a Store message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns Store + */ + public static fromObject(object: { [k: string]: any }): Store; + + /** + * Creates a plain object from a Store message. Also converts values to other types if specified. + * @param message Store + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: Store, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this Store to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; +} diff --git a/src/ddsketch/proto/compiled.js b/src/ddsketch/proto/compiled.js new file mode 100644 index 0000000..21f3891 --- /dev/null +++ b/src/ddsketch/proto/compiled.js @@ -0,0 +1,849 @@ +/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/ +"use strict"; + +var $protobuf = require("protobufjs/minimal"); + +// Common aliases +var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util; + +// Exported root namespace +var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {}); + +$root.DDSketch = (function() { + + /** + * Properties of a DDSketch. + * @exports IDDSketch + * @interface IDDSketch + * @property {IIndexMapping|null} [mapping] DDSketch mapping + * @property {IStore|null} [positiveValues] DDSketch positiveValues + * @property {IStore|null} [negativeValues] DDSketch negativeValues + * @property {number|null} [zeroCount] DDSketch zeroCount + */ + + /** + * Constructs a new DDSketch. + * @exports DDSketch + * @classdesc Represents a DDSketch. + * @implements IDDSketch + * @constructor + * @param {IDDSketch=} [properties] Properties to set + */ + function DDSketch(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * DDSketch mapping. + * @member {IIndexMapping|null|undefined} mapping + * @memberof DDSketch + * @instance + */ + DDSketch.prototype.mapping = null; + + /** + * DDSketch positiveValues. + * @member {IStore|null|undefined} positiveValues + * @memberof DDSketch + * @instance + */ + DDSketch.prototype.positiveValues = null; + + /** + * DDSketch negativeValues. + * @member {IStore|null|undefined} negativeValues + * @memberof DDSketch + * @instance + */ + DDSketch.prototype.negativeValues = null; + + /** + * DDSketch zeroCount. + * @member {number} zeroCount + * @memberof DDSketch + * @instance + */ + DDSketch.prototype.zeroCount = 0; + + /** + * Creates a new DDSketch instance using the specified properties. + * @function create + * @memberof DDSketch + * @static + * @param {IDDSketch=} [properties] Properties to set + * @returns {DDSketch} DDSketch instance + */ + DDSketch.create = function create(properties) { + return new DDSketch(properties); + }; + + /** + * Encodes the specified DDSketch message. Does not implicitly {@link DDSketch.verify|verify} messages. + * @function encode + * @memberof DDSketch + * @static + * @param {IDDSketch} message DDSketch message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + DDSketch.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.mapping != null && Object.hasOwnProperty.call(message, "mapping")) + $root.IndexMapping.encode(message.mapping, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + if (message.positiveValues != null && Object.hasOwnProperty.call(message, "positiveValues")) + $root.Store.encode(message.positiveValues, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + if (message.negativeValues != null && Object.hasOwnProperty.call(message, "negativeValues")) + $root.Store.encode(message.negativeValues, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + if (message.zeroCount != null && Object.hasOwnProperty.call(message, "zeroCount")) + writer.uint32(/* id 4, wireType 1 =*/33).double(message.zeroCount); + return writer; + }; + + /** + * Encodes the specified DDSketch message, length delimited. Does not implicitly {@link DDSketch.verify|verify} messages. + * @function encodeDelimited + * @memberof DDSketch + * @static + * @param {IDDSketch} message DDSketch message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + DDSketch.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a DDSketch message from the specified reader or buffer. + * @function decode + * @memberof DDSketch + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {DDSketch} DDSketch + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + DDSketch.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.DDSketch(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.mapping = $root.IndexMapping.decode(reader, reader.uint32()); + break; + case 2: + message.positiveValues = $root.Store.decode(reader, reader.uint32()); + break; + case 3: + message.negativeValues = $root.Store.decode(reader, reader.uint32()); + break; + case 4: + message.zeroCount = reader.double(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a DDSketch message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof DDSketch + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {DDSketch} DDSketch + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + DDSketch.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a DDSketch message. + * @function verify + * @memberof DDSketch + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + DDSketch.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.mapping != null && message.hasOwnProperty("mapping")) { + var error = $root.IndexMapping.verify(message.mapping); + if (error) + return "mapping." + error; + } + if (message.positiveValues != null && message.hasOwnProperty("positiveValues")) { + var error = $root.Store.verify(message.positiveValues); + if (error) + return "positiveValues." + error; + } + if (message.negativeValues != null && message.hasOwnProperty("negativeValues")) { + var error = $root.Store.verify(message.negativeValues); + if (error) + return "negativeValues." + error; + } + if (message.zeroCount != null && message.hasOwnProperty("zeroCount")) + if (typeof message.zeroCount !== "number") + return "zeroCount: number expected"; + return null; + }; + + /** + * Creates a DDSketch message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof DDSketch + * @static + * @param {Object.} object Plain object + * @returns {DDSketch} DDSketch + */ + DDSketch.fromObject = function fromObject(object) { + if (object instanceof $root.DDSketch) + return object; + var message = new $root.DDSketch(); + if (object.mapping != null) { + if (typeof object.mapping !== "object") + throw TypeError(".DDSketch.mapping: object expected"); + message.mapping = $root.IndexMapping.fromObject(object.mapping); + } + if (object.positiveValues != null) { + if (typeof object.positiveValues !== "object") + throw TypeError(".DDSketch.positiveValues: object expected"); + message.positiveValues = $root.Store.fromObject(object.positiveValues); + } + if (object.negativeValues != null) { + if (typeof object.negativeValues !== "object") + throw TypeError(".DDSketch.negativeValues: object expected"); + message.negativeValues = $root.Store.fromObject(object.negativeValues); + } + if (object.zeroCount != null) + message.zeroCount = Number(object.zeroCount); + return message; + }; + + /** + * Creates a plain object from a DDSketch message. Also converts values to other types if specified. + * @function toObject + * @memberof DDSketch + * @static + * @param {DDSketch} message DDSketch + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + DDSketch.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.mapping = null; + object.positiveValues = null; + object.negativeValues = null; + object.zeroCount = 0; + } + if (message.mapping != null && message.hasOwnProperty("mapping")) + object.mapping = $root.IndexMapping.toObject(message.mapping, options); + if (message.positiveValues != null && message.hasOwnProperty("positiveValues")) + object.positiveValues = $root.Store.toObject(message.positiveValues, options); + if (message.negativeValues != null && message.hasOwnProperty("negativeValues")) + object.negativeValues = $root.Store.toObject(message.negativeValues, options); + if (message.zeroCount != null && message.hasOwnProperty("zeroCount")) + object.zeroCount = options.json && !isFinite(message.zeroCount) ? String(message.zeroCount) : message.zeroCount; + return object; + }; + + /** + * Converts this DDSketch to JSON. + * @function toJSON + * @memberof DDSketch + * @instance + * @returns {Object.} JSON object + */ + DDSketch.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return DDSketch; +})(); + +$root.IndexMapping = (function() { + + /** + * Properties of an IndexMapping. + * @exports IIndexMapping + * @interface IIndexMapping + * @property {number|null} [gamma] IndexMapping gamma + * @property {number|null} [indexOffset] IndexMapping indexOffset + * @property {IndexMapping.Interpolation|null} [interpolation] IndexMapping interpolation + */ + + /** + * Constructs a new IndexMapping. + * @exports IndexMapping + * @classdesc Represents an IndexMapping. + * @implements IIndexMapping + * @constructor + * @param {IIndexMapping=} [properties] Properties to set + */ + function IndexMapping(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * IndexMapping gamma. + * @member {number} gamma + * @memberof IndexMapping + * @instance + */ + IndexMapping.prototype.gamma = 0; + + /** + * IndexMapping indexOffset. + * @member {number} indexOffset + * @memberof IndexMapping + * @instance + */ + IndexMapping.prototype.indexOffset = 0; + + /** + * IndexMapping interpolation. + * @member {IndexMapping.Interpolation} interpolation + * @memberof IndexMapping + * @instance + */ + IndexMapping.prototype.interpolation = 0; + + /** + * Creates a new IndexMapping instance using the specified properties. + * @function create + * @memberof IndexMapping + * @static + * @param {IIndexMapping=} [properties] Properties to set + * @returns {IndexMapping} IndexMapping instance + */ + IndexMapping.create = function create(properties) { + return new IndexMapping(properties); + }; + + /** + * Encodes the specified IndexMapping message. Does not implicitly {@link IndexMapping.verify|verify} messages. + * @function encode + * @memberof IndexMapping + * @static + * @param {IIndexMapping} message IndexMapping message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + IndexMapping.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.gamma != null && Object.hasOwnProperty.call(message, "gamma")) + writer.uint32(/* id 1, wireType 1 =*/9).double(message.gamma); + if (message.indexOffset != null && Object.hasOwnProperty.call(message, "indexOffset")) + writer.uint32(/* id 2, wireType 1 =*/17).double(message.indexOffset); + if (message.interpolation != null && Object.hasOwnProperty.call(message, "interpolation")) + writer.uint32(/* id 3, wireType 0 =*/24).int32(message.interpolation); + return writer; + }; + + /** + * Encodes the specified IndexMapping message, length delimited. Does not implicitly {@link IndexMapping.verify|verify} messages. + * @function encodeDelimited + * @memberof IndexMapping + * @static + * @param {IIndexMapping} message IndexMapping message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + IndexMapping.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes an IndexMapping message from the specified reader or buffer. + * @function decode + * @memberof IndexMapping + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {IndexMapping} IndexMapping + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + IndexMapping.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.IndexMapping(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.gamma = reader.double(); + break; + case 2: + message.indexOffset = reader.double(); + break; + case 3: + message.interpolation = reader.int32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes an IndexMapping message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof IndexMapping + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {IndexMapping} IndexMapping + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + IndexMapping.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies an IndexMapping message. + * @function verify + * @memberof IndexMapping + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + IndexMapping.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.gamma != null && message.hasOwnProperty("gamma")) + if (typeof message.gamma !== "number") + return "gamma: number expected"; + if (message.indexOffset != null && message.hasOwnProperty("indexOffset")) + if (typeof message.indexOffset !== "number") + return "indexOffset: number expected"; + if (message.interpolation != null && message.hasOwnProperty("interpolation")) + switch (message.interpolation) { + default: + return "interpolation: enum value expected"; + case 0: + case 1: + case 2: + case 3: + break; + } + return null; + }; + + /** + * Creates an IndexMapping message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof IndexMapping + * @static + * @param {Object.} object Plain object + * @returns {IndexMapping} IndexMapping + */ + IndexMapping.fromObject = function fromObject(object) { + if (object instanceof $root.IndexMapping) + return object; + var message = new $root.IndexMapping(); + if (object.gamma != null) + message.gamma = Number(object.gamma); + if (object.indexOffset != null) + message.indexOffset = Number(object.indexOffset); + switch (object.interpolation) { + case "NONE": + case 0: + message.interpolation = 0; + break; + case "LINEAR": + case 1: + message.interpolation = 1; + break; + case "QUADRATIC": + case 2: + message.interpolation = 2; + break; + case "CUBIC": + case 3: + message.interpolation = 3; + break; + } + return message; + }; + + /** + * Creates a plain object from an IndexMapping message. Also converts values to other types if specified. + * @function toObject + * @memberof IndexMapping + * @static + * @param {IndexMapping} message IndexMapping + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + IndexMapping.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.gamma = 0; + object.indexOffset = 0; + object.interpolation = options.enums === String ? "NONE" : 0; + } + if (message.gamma != null && message.hasOwnProperty("gamma")) + object.gamma = options.json && !isFinite(message.gamma) ? String(message.gamma) : message.gamma; + if (message.indexOffset != null && message.hasOwnProperty("indexOffset")) + object.indexOffset = options.json && !isFinite(message.indexOffset) ? String(message.indexOffset) : message.indexOffset; + if (message.interpolation != null && message.hasOwnProperty("interpolation")) + object.interpolation = options.enums === String ? $root.IndexMapping.Interpolation[message.interpolation] : message.interpolation; + return object; + }; + + /** + * Converts this IndexMapping to JSON. + * @function toJSON + * @memberof IndexMapping + * @instance + * @returns {Object.} JSON object + */ + IndexMapping.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + /** + * Interpolation enum. + * @name IndexMapping.Interpolation + * @enum {number} + * @property {number} NONE=0 NONE value + * @property {number} LINEAR=1 LINEAR value + * @property {number} QUADRATIC=2 QUADRATIC value + * @property {number} CUBIC=3 CUBIC value + */ + IndexMapping.Interpolation = (function() { + var valuesById = {}, values = Object.create(valuesById); + values[valuesById[0] = "NONE"] = 0; + values[valuesById[1] = "LINEAR"] = 1; + values[valuesById[2] = "QUADRATIC"] = 2; + values[valuesById[3] = "CUBIC"] = 3; + return values; + })(); + + return IndexMapping; +})(); + +$root.Store = (function() { + + /** + * Properties of a Store. + * @exports IStore + * @interface IStore + * @property {Object.|null} [binCounts] Store binCounts + * @property {Array.|null} [contiguousBinCounts] Store contiguousBinCounts + * @property {number|null} [contiguousBinIndexOffset] Store contiguousBinIndexOffset + */ + + /** + * Constructs a new Store. + * @exports Store + * @classdesc Represents a Store. + * @implements IStore + * @constructor + * @param {IStore=} [properties] Properties to set + */ + function Store(properties) { + this.binCounts = {}; + this.contiguousBinCounts = []; + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * Store binCounts. + * @member {Object.} binCounts + * @memberof Store + * @instance + */ + Store.prototype.binCounts = $util.emptyObject; + + /** + * Store contiguousBinCounts. + * @member {Array.} contiguousBinCounts + * @memberof Store + * @instance + */ + Store.prototype.contiguousBinCounts = $util.emptyArray; + + /** + * Store contiguousBinIndexOffset. + * @member {number} contiguousBinIndexOffset + * @memberof Store + * @instance + */ + Store.prototype.contiguousBinIndexOffset = 0; + + /** + * Creates a new Store instance using the specified properties. + * @function create + * @memberof Store + * @static + * @param {IStore=} [properties] Properties to set + * @returns {Store} Store instance + */ + Store.create = function create(properties) { + return new Store(properties); + }; + + /** + * Encodes the specified Store message. Does not implicitly {@link Store.verify|verify} messages. + * @function encode + * @memberof Store + * @static + * @param {IStore} message Store message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Store.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.binCounts != null && Object.hasOwnProperty.call(message, "binCounts")) + for (var keys = Object.keys(message.binCounts), i = 0; i < keys.length; ++i) + writer.uint32(/* id 1, wireType 2 =*/10).fork().uint32(/* id 1, wireType 0 =*/8).sint32(keys[i]).uint32(/* id 2, wireType 1 =*/17).double(message.binCounts[keys[i]]).ldelim(); + if (message.contiguousBinCounts != null && message.contiguousBinCounts.length) { + writer.uint32(/* id 2, wireType 2 =*/18).fork(); + for (var i = 0; i < message.contiguousBinCounts.length; ++i) + writer.double(message.contiguousBinCounts[i]); + writer.ldelim(); + } + if (message.contiguousBinIndexOffset != null && Object.hasOwnProperty.call(message, "contiguousBinIndexOffset")) + writer.uint32(/* id 3, wireType 0 =*/24).sint32(message.contiguousBinIndexOffset); + return writer; + }; + + /** + * Encodes the specified Store message, length delimited. Does not implicitly {@link Store.verify|verify} messages. + * @function encodeDelimited + * @memberof Store + * @static + * @param {IStore} message Store message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + Store.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a Store message from the specified reader or buffer. + * @function decode + * @memberof Store + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {Store} Store + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Store.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.Store(), key, value; + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (message.binCounts === $util.emptyObject) + message.binCounts = {}; + var end2 = reader.uint32() + reader.pos; + key = 0; + value = 0; + while (reader.pos < end2) { + var tag2 = reader.uint32(); + switch (tag2 >>> 3) { + case 1: + key = reader.sint32(); + break; + case 2: + value = reader.double(); + break; + default: + reader.skipType(tag2 & 7); + break; + } + } + message.binCounts[key] = value; + break; + case 2: + if (!(message.contiguousBinCounts && message.contiguousBinCounts.length)) + message.contiguousBinCounts = []; + if ((tag & 7) === 2) { + var end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) + message.contiguousBinCounts.push(reader.double()); + } else + message.contiguousBinCounts.push(reader.double()); + break; + case 3: + message.contiguousBinIndexOffset = reader.sint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a Store message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof Store + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {Store} Store + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + Store.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a Store message. + * @function verify + * @memberof Store + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + Store.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.binCounts != null && message.hasOwnProperty("binCounts")) { + if (!$util.isObject(message.binCounts)) + return "binCounts: object expected"; + var key = Object.keys(message.binCounts); + for (var i = 0; i < key.length; ++i) { + if (!$util.key32Re.test(key[i])) + return "binCounts: integer key{k:sint32} expected"; + if (typeof message.binCounts[key[i]] !== "number") + return "binCounts: number{k:sint32} expected"; + } + } + if (message.contiguousBinCounts != null && message.hasOwnProperty("contiguousBinCounts")) { + if (!Array.isArray(message.contiguousBinCounts)) + return "contiguousBinCounts: array expected"; + for (var i = 0; i < message.contiguousBinCounts.length; ++i) + if (typeof message.contiguousBinCounts[i] !== "number") + return "contiguousBinCounts: number[] expected"; + } + if (message.contiguousBinIndexOffset != null && message.hasOwnProperty("contiguousBinIndexOffset")) + if (!$util.isInteger(message.contiguousBinIndexOffset)) + return "contiguousBinIndexOffset: integer expected"; + return null; + }; + + /** + * Creates a Store message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof Store + * @static + * @param {Object.} object Plain object + * @returns {Store} Store + */ + Store.fromObject = function fromObject(object) { + if (object instanceof $root.Store) + return object; + var message = new $root.Store(); + if (object.binCounts) { + if (typeof object.binCounts !== "object") + throw TypeError(".Store.binCounts: object expected"); + message.binCounts = {}; + for (var keys = Object.keys(object.binCounts), i = 0; i < keys.length; ++i) + message.binCounts[keys[i]] = Number(object.binCounts[keys[i]]); + } + if (object.contiguousBinCounts) { + if (!Array.isArray(object.contiguousBinCounts)) + throw TypeError(".Store.contiguousBinCounts: array expected"); + message.contiguousBinCounts = []; + for (var i = 0; i < object.contiguousBinCounts.length; ++i) + message.contiguousBinCounts[i] = Number(object.contiguousBinCounts[i]); + } + if (object.contiguousBinIndexOffset != null) + message.contiguousBinIndexOffset = object.contiguousBinIndexOffset | 0; + return message; + }; + + /** + * Creates a plain object from a Store message. Also converts values to other types if specified. + * @function toObject + * @memberof Store + * @static + * @param {Store} message Store + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + Store.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) + object.contiguousBinCounts = []; + if (options.objects || options.defaults) + object.binCounts = {}; + if (options.defaults) + object.contiguousBinIndexOffset = 0; + var keys2; + if (message.binCounts && (keys2 = Object.keys(message.binCounts)).length) { + object.binCounts = {}; + for (var j = 0; j < keys2.length; ++j) + object.binCounts[keys2[j]] = options.json && !isFinite(message.binCounts[keys2[j]]) ? String(message.binCounts[keys2[j]]) : message.binCounts[keys2[j]]; + } + if (message.contiguousBinCounts && message.contiguousBinCounts.length) { + object.contiguousBinCounts = []; + for (var j = 0; j < message.contiguousBinCounts.length; ++j) + object.contiguousBinCounts[j] = options.json && !isFinite(message.contiguousBinCounts[j]) ? String(message.contiguousBinCounts[j]) : message.contiguousBinCounts[j]; + } + if (message.contiguousBinIndexOffset != null && message.hasOwnProperty("contiguousBinIndexOffset")) + object.contiguousBinIndexOffset = message.contiguousBinIndexOffset; + return object; + }; + + /** + * Converts this Store to JSON. + * @function toJSON + * @memberof Store + * @instance + * @returns {Object.} JSON object + */ + Store.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return Store; +})(); + +module.exports = $root; diff --git a/yarn.lock b/yarn.lock index 9d9e2f4..5396dbd 100644 --- a/yarn.lock +++ b/yarn.lock @@ -505,6 +505,59 @@ "@nodelib/fs.scandir" "2.1.3" fastq "^1.6.0" +"@protobufjs/aspromise@^1.1.1", "@protobufjs/aspromise@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/aspromise/-/aspromise-1.1.2.tgz#9b8b0cc663d669a7d8f6f5d0893a14d348f30fbf" + integrity sha1-m4sMxmPWaafY9vXQiToU00jzD78= + +"@protobufjs/base64@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/base64/-/base64-1.1.2.tgz#4c85730e59b9a1f1f349047dbf24296034bb2735" + integrity sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg== + +"@protobufjs/codegen@^2.0.4": + version "2.0.4" + resolved "https://registry.yarnpkg.com/@protobufjs/codegen/-/codegen-2.0.4.tgz#7ef37f0d010fb028ad1ad59722e506d9262815cb" + integrity sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg== + +"@protobufjs/eventemitter@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz#355cbc98bafad5978f9ed095f397621f1d066b70" + integrity sha1-NVy8mLr61ZePntCV85diHx0Ga3A= + +"@protobufjs/fetch@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/fetch/-/fetch-1.1.0.tgz#ba99fb598614af65700c1619ff06d454b0d84c45" + integrity sha1-upn7WYYUr2VwDBYZ/wbUVLDYTEU= + dependencies: + "@protobufjs/aspromise" "^1.1.1" + "@protobufjs/inquire" "^1.1.0" + +"@protobufjs/float@^1.0.2": + version "1.0.2" + resolved "https://registry.yarnpkg.com/@protobufjs/float/-/float-1.0.2.tgz#5e9e1abdcb73fc0a7cb8b291df78c8cbd97b87d1" + integrity sha1-Xp4avctz/Ap8uLKR33jIy9l7h9E= + +"@protobufjs/inquire@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/inquire/-/inquire-1.1.0.tgz#ff200e3e7cf2429e2dcafc1140828e8cc638f089" + integrity sha1-/yAOPnzyQp4tyvwRQIKOjMY48Ik= + +"@protobufjs/path@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/path/-/path-1.1.2.tgz#6cc2b20c5c9ad6ad0dccfd21ca7673d8d7fbf68d" + integrity sha1-bMKyDFya1q0NzP0hynZz2Nf79o0= + +"@protobufjs/pool@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/pool/-/pool-1.1.0.tgz#09fd15f2d6d3abfa9b65bc366506d6ad7846ff54" + integrity sha1-Cf0V8tbTq/qbZbw2ZQbWrXhG/1Q= + +"@protobufjs/utf8@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/utf8/-/utf8-1.1.0.tgz#a777360b5b39a1a2e5106f8e858f2fd2d060c570" + integrity sha1-p3c2C1s5oaLlEG+OhY8v0tBgxXA= + "@sinonjs/commons@^1.7.0": version "1.8.1" resolved "https://registry.yarnpkg.com/@sinonjs/commons/-/commons-1.8.1.tgz#e7df00f98a203324f6dc7cc606cad9d4a8ab2217" @@ -604,11 +657,21 @@ resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.6.tgz#f4c7ec43e81b319a9815115031709f26987891f0" integrity sha512-3c+yGKvVP5Y9TYBEibGNR+kLtijnj7mYrXRg+WpFb2X9xm04g/DXYkfg4hmzJQosc9snFNUPkbYIhu+KAm6jJw== +"@types/long@^4.0.1": + version "4.0.1" + resolved "https://registry.yarnpkg.com/@types/long/-/long-4.0.1.tgz#459c65fa1867dafe6a8f322c4c51695663cc55e9" + integrity sha512-5tXH6Bx/kNGd3MgffdmP4dy2Z+G4eaXw0SE81Tq3BNadtnMR5/ySMzX4SLEzHJzSmPNn4HIdpQsBvXMUykr58w== + "@types/node@*": version "14.11.2" resolved "https://registry.yarnpkg.com/@types/node/-/node-14.11.2.tgz#2de1ed6670439387da1c9f549a2ade2b0a799256" integrity sha512-jiE3QIxJ8JLNcb1Ps6rDbysDhN4xa8DJJvuC9prr6w+1tIh+QAbYyNF3tyiZNLDBIuBCf4KEcV2UvQm/V60xfA== +"@types/node@^13.7.0": + version "13.13.34" + resolved "https://registry.yarnpkg.com/@types/node/-/node-13.13.34.tgz#c9300a1b6560d90817fb2bba650e250116a575f9" + integrity sha512-g8D1HF2dMDKYSDl5+79izRwRgNPsSynmWMbj50mj7GZ0b7Lv4p8EmZjbo3h0h+6iLr6YmVz9VnF6XVZ3O6V1Ug== + "@types/normalize-package-data@^2.4.0": version "2.4.0" resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.0.tgz#e486d0d97396d79beedd0a6e33f4534ff6b4973e" @@ -2972,6 +3035,11 @@ lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19: resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.20.tgz#b44a9b6297bcb698f1c51a3545a2b3b368d59c52" integrity sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA== +long@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/long/-/long-4.0.0.tgz#9a7b71cfb7d361a194ea555241c92f7468d5bf28" + integrity sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA== + lowercase-keys@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-1.0.1.tgz#6f9e30b47084d971a7c820ff15a6c5167b74c26f" @@ -3583,6 +3651,25 @@ prompts@^2.0.1: kleur "^3.0.3" sisteransi "^1.0.4" +protobufjs@^6.10.2: + version "6.10.2" + resolved "https://registry.yarnpkg.com/protobufjs/-/protobufjs-6.10.2.tgz#b9cb6bd8ec8f87514592ba3fdfd28e93f33a469b" + integrity sha512-27yj+04uF6ya9l+qfpH187aqEzfCF4+Uit0I9ZBQVqK09hk/SQzKa2MUqUpXaVa7LOFRg1TSSr3lVxGOk6c0SQ== + dependencies: + "@protobufjs/aspromise" "^1.1.2" + "@protobufjs/base64" "^1.1.2" + "@protobufjs/codegen" "^2.0.4" + "@protobufjs/eventemitter" "^1.1.0" + "@protobufjs/fetch" "^1.1.0" + "@protobufjs/float" "^1.0.2" + "@protobufjs/inquire" "^1.1.0" + "@protobufjs/path" "^1.1.2" + "@protobufjs/pool" "^1.1.0" + "@protobufjs/utf8" "^1.1.0" + "@types/long" "^4.0.1" + "@types/node" "^13.7.0" + long "^4.0.0" + psl@^1.1.28: version "1.8.0" resolved "https://registry.yarnpkg.com/psl/-/psl-1.8.0.tgz#9326f8bcfb013adcc005fdff056acce020e51c24"