Initialisation

Added the packages and files for the backend server

README.md

@@ -0,0 +1,2 @@
+1) initialised using npm init --yes && npm pkg set type="module"
+2) Installed dependencies npm install @apollo/server graphql

node_modules/.bin/apollo-pbjs

@@ -0,0 +1 @@
+../@apollo/protobufjs/bin/pbjs

node_modules/.bin/apollo-pbts

@@ -0,0 +1 @@
+../@apollo/protobufjs/bin/pbts

node_modules/.bin/mime

@@ -0,0 +1 @@
+../mime/cli.js

node_modules/.bin/sha.js

@@ -0,0 +1 @@
+../sha.js/bin.js

node_modules/.bin/uuid

@@ -0,0 +1 @@
+../uuid/dist/bin/uuid

node_modules/@apollo/cache-control-types/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Apollo Graph, Inc. (Formerly Meteor Development Group, 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.

node_modules/@apollo/cache-control-types/README.md

@@ -0,0 +1,6 @@
+# Cache Control types
+
+This package exports various TypeScript types related to Apollo Server's cache
+policy calculation.
+
+Specifically, it gives a type-safe way to get the `info.cacheControl` field in resolvers. Either declare your resolver's `info` argument to be of type `GraphQLResolveInfoWithCacheControl` (perhaps with the graphql-code-generator typescript-resolvers customResolveInfo option), or use the `maybeCacheControlFromInfo` or `cacheControlFromInfo` functions to extract `info.cacheControl` in a type-safe way.

node_modules/@apollo/cache-control-types/dist/cjs/index.d.ts

@@ -0,0 +1,22 @@
+import type { GraphQLCompositeType, GraphQLResolveInfo } from 'graphql';
+export type CacheScope = 'PUBLIC' | 'PRIVATE';
+export interface CacheHint {
+    maxAge?: number;
+    scope?: CacheScope;
+}
+export interface CachePolicy extends CacheHint {
+    replace(hint: CacheHint): void;
+    restrict(hint: CacheHint): void;
+    policyIfCacheable(): Required<CacheHint> | null;
+}
+export interface ResolveInfoCacheControl {
+    cacheHint: CachePolicy;
+    setCacheHint(hint: CacheHint): void;
+    cacheHintFromType(t: GraphQLCompositeType): CacheHint | undefined;
+}
+export interface GraphQLResolveInfoWithCacheControl extends Omit<GraphQLResolveInfo, 'cacheControl'> {
+    cacheControl: ResolveInfoCacheControl;
+}
+export declare function maybeCacheControlFromInfo(info: GraphQLResolveInfo): ResolveInfoCacheControl | null;
+export declare function cacheControlFromInfo(info: GraphQLResolveInfo): ResolveInfoCacheControl;
+//# sourceMappingURL=index.d.ts.map

node_modules/@apollo/cache-control-types/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAMxE,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;AAM9C,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB;AAMD,MAAM,WAAW,WAAY,SAAQ,SAAS;IAK5C,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IAO/B,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IAMhC,iBAAiB,IAAI,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;CACjD;AAMD,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,WAAW,CAAC;IAGvB,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IAEpC,iBAAiB,CAAC,CAAC,EAAE,oBAAoB,GAAG,SAAS,GAAG,SAAS,CAAC;CACnE;AAMD,MAAM,WAAW,kCACf,SAAQ,IAAI,CAAC,kBAAkB,EAAE,cAAc,CAAC;IAYhD,YAAY,EAAE,uBAAuB,CAAC;CACvC;AAKD,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,kBAAkB,GACvB,uBAAuB,GAAG,IAAI,CAKhC;AAKD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,kBAAkB,GACvB,uBAAuB,CAgBzB"}

node_modules/@apollo/cache-control-types/dist/cjs/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheControlFromInfo = exports.maybeCacheControlFromInfo = void 0;
+function maybeCacheControlFromInfo(info) {
+    if (info.cacheControl?.cacheHint?.restrict) {
+        return info.cacheControl;
+    }
+    return null;
+}
+exports.maybeCacheControlFromInfo = maybeCacheControlFromInfo;
+function cacheControlFromInfo(info) {
+    if (!('cacheControl' in info)) {
+        throw new Error('The `info` argument does not appear to have a cacheControl field. ' +
+            "Check that you are using Apollo Server 3 or newer and that you aren't using " +
+            'ApolloServerPluginCacheControlDisabled.');
+    }
+    if (!info.cacheControl?.cacheHint?.restrict) {
+        throw new Error('The `info` argument has a cacheControl field but it does not appear to be from Apollo' +
+            "Server 3 or newer. Check that you are using Apollo Server 3 or newer and that you aren't using " +
+            'ApolloServerPluginCacheControlDisabled.');
+    }
+    return info.cacheControl;
+}
+exports.cacheControlFromInfo = cacheControlFromInfo;
+//# sourceMappingURL=index.js.map

node_modules/@apollo/cache-control-types/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAmFA,SAAgB,yBAAyB,CACvC,IAAwB;IAExB,IAAK,IAAY,CAAC,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE;QACnD,OAAQ,IAAY,CAAC,YAAY,CAAC;KACnC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAPD,8DAOC;AAKD,SAAgB,oBAAoB,CAClC,IAAwB;IAExB,IAAI,CAAC,CAAC,cAAc,IAAI,IAAI,CAAC,EAAE;QAC7B,MAAM,IAAI,KAAK,CACb,oEAAoE;YAClE,8EAA8E;YAC9E,yCAAyC,CAC5C,CAAC;KACH;IACD,IAAI,CAAE,IAAY,CAAC,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE;QACpD,MAAM,IAAI,KAAK,CACb,uFAAuF;YACrF,iGAAiG;YACjG,yCAAyC,CAC5C,CAAC;KACH;IACD,OAAQ,IAAY,CAAC,YAAY,CAAC;AACpC,CAAC;AAlBD,oDAkBC"}

node_modules/@apollo/cache-control-types/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

node_modules/@apollo/cache-control-types/dist/esm/index.d.ts

@@ -0,0 +1,22 @@
+import type { GraphQLCompositeType, GraphQLResolveInfo } from 'graphql';
+export type CacheScope = 'PUBLIC' | 'PRIVATE';
+export interface CacheHint {
+    maxAge?: number;
+    scope?: CacheScope;
+}
+export interface CachePolicy extends CacheHint {
+    replace(hint: CacheHint): void;
+    restrict(hint: CacheHint): void;
+    policyIfCacheable(): Required<CacheHint> | null;
+}
+export interface ResolveInfoCacheControl {
+    cacheHint: CachePolicy;
+    setCacheHint(hint: CacheHint): void;
+    cacheHintFromType(t: GraphQLCompositeType): CacheHint | undefined;
+}
+export interface GraphQLResolveInfoWithCacheControl extends Omit<GraphQLResolveInfo, 'cacheControl'> {
+    cacheControl: ResolveInfoCacheControl;
+}
+export declare function maybeCacheControlFromInfo(info: GraphQLResolveInfo): ResolveInfoCacheControl | null;
+export declare function cacheControlFromInfo(info: GraphQLResolveInfo): ResolveInfoCacheControl;
+//# sourceMappingURL=index.d.ts.map

node_modules/@apollo/cache-control-types/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAMxE,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;AAM9C,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB;AAMD,MAAM,WAAW,WAAY,SAAQ,SAAS;IAK5C,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IAO/B,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IAMhC,iBAAiB,IAAI,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;CACjD;AAMD,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,WAAW,CAAC;IAGvB,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IAEpC,iBAAiB,CAAC,CAAC,EAAE,oBAAoB,GAAG,SAAS,GAAG,SAAS,CAAC;CACnE;AAMD,MAAM,WAAW,kCACf,SAAQ,IAAI,CAAC,kBAAkB,EAAE,cAAc,CAAC;IAYhD,YAAY,EAAE,uBAAuB,CAAC;CACvC;AAKD,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,kBAAkB,GACvB,uBAAuB,GAAG,IAAI,CAKhC;AAKD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,kBAAkB,GACvB,uBAAuB,CAgBzB"}

node_modules/@apollo/cache-control-types/dist/esm/index.js

@@ -0,0 +1,20 @@
+export function maybeCacheControlFromInfo(info) {
+    if (info.cacheControl?.cacheHint?.restrict) {
+        return info.cacheControl;
+    }
+    return null;
+}
+export function cacheControlFromInfo(info) {
+    if (!('cacheControl' in info)) {
+        throw new Error('The `info` argument does not appear to have a cacheControl field. ' +
+            "Check that you are using Apollo Server 3 or newer and that you aren't using " +
+            'ApolloServerPluginCacheControlDisabled.');
+    }
+    if (!info.cacheControl?.cacheHint?.restrict) {
+        throw new Error('The `info` argument has a cacheControl field but it does not appear to be from Apollo' +
+            "Server 3 or newer. Check that you are using Apollo Server 3 or newer and that you aren't using " +
+            'ApolloServerPluginCacheControlDisabled.');
+    }
+    return info.cacheControl;
+}
+//# sourceMappingURL=index.js.map

node_modules/@apollo/cache-control-types/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAmFA,MAAM,UAAU,yBAAyB,CACvC,IAAwB;IAExB,IAAK,IAAY,CAAC,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE;QACnD,OAAQ,IAAY,CAAC,YAAY,CAAC;KACnC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAKD,MAAM,UAAU,oBAAoB,CAClC,IAAwB;IAExB,IAAI,CAAC,CAAC,cAAc,IAAI,IAAI,CAAC,EAAE;QAC7B,MAAM,IAAI,KAAK,CACb,oEAAoE;YAClE,8EAA8E;YAC9E,yCAAyC,CAC5C,CAAC;KACH;IACD,IAAI,CAAE,IAAY,CAAC,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE;QACpD,MAAM,IAAI,KAAK,CACb,uFAAuF;YACrF,iGAAiG;YACjG,yCAAyC,CAC5C,CAAC;KACH;IACD,OAAQ,IAAY,CAAC,YAAY,CAAC;AACpC,CAAC"}

node_modules/@apollo/cache-control-types/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/@apollo/cache-control-types/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@apollo/cache-control-types",
+  "version": "1.0.3",
+  "description": "TypeScript types for Apollo Server info.cacheControl",
+  "type": "module",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "require": "./dist/cjs/index.d.ts",
+        "default": "./dist/esm/index.d.ts"
+      },
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apollographql/apollo-server.git",
+    "directory": "packages/cache-control-types/"
+  },
+  "keywords": [
+    "apollo",
+    "graphql",
+    "typescript",
+    "node"
+  ],
+  "author": "Apollo <packages@apollographql.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/apollographql/apollo-server/issues"
+  },
+  "homepage": "https://github.com/apollographql/apollo-server#readme",
+  "peerDependencies": {
+    "graphql": "14.x || 15.x || 16.x"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  }
+}

node_modules/@apollo/cache-control-types/src/index.ts

@@ -0,0 +1,114 @@
+// NOTE: Once Apollo Server 4 is released, move this package into the
+// apollo-server repo. We're placing it in the apollo-utils repo for now to
+// enable us to make non-alpha releases that can be used on the apollo-server
+// version-4 branch.
+
+import type { GraphQLCompositeType, GraphQLResolveInfo } from 'graphql';
+
+/**
+ * CacheScope represents whether cacheable data should be shared across sessions
+ * (PUBLIC) or considered session-specific (PRIVATE).
+ */
+export type CacheScope = 'PUBLIC' | 'PRIVATE';
+
+/**
+ * CacheHint represents a contribution to an overall cache policy. It can
+ * specify a maxAge and/or a scope.
+ */
+export interface CacheHint {
+  maxAge?: number;
+  scope?: CacheScope;
+}
+
+/**
+ * CachePolicy is a mutable CacheHint with helpful methods for updating its
+ * fields.
+ */
+export interface CachePolicy extends CacheHint {
+  /**
+   * Mutate this CachePolicy by replacing each field defined in `hint`. This can
+   * make the policy more restrictive or less restrictive.
+   */
+  replace(hint: CacheHint): void;
+
+  /**
+   * Mutate this CachePolicy by restricting each field defined in `hint`. This
+   * can only make the policy more restrictive: a previously defined `maxAge`
+   * can only be reduced, and a previously Private scope cannot be made Public.
+   */
+  restrict(hint: CacheHint): void;
+
+  /**
+   * If this policy has a positive `maxAge`, then return a copy of itself as a
+   * `CacheHint` with both fields defined. Otherwise return null.
+   */
+  policyIfCacheable(): Required<CacheHint> | null;
+}
+
+/**
+ * When using Apollo Server with the cache control plugin (on by default), an
+ * object of this kind is available to resolvers on `info.cacheControl`.
+ */
+export interface ResolveInfoCacheControl {
+  cacheHint: CachePolicy;
+  // Shorthand for `cacheHint.replace(hint)`; also for compatibility with
+  // the Apollo Server 2.x API.
+  setCacheHint(hint: CacheHint): void;
+
+  cacheHintFromType(t: GraphQLCompositeType): CacheHint | undefined;
+}
+
+/** When using Apollo Server with the cache control plugin (on by default), the
+ * `info` argument to resolvers can be considered to be of this type. (You can
+ * use this type with the customResolveInfo option to the graphql-code-generator
+ * typescript-resolvers plugin, for example.) */
+export interface GraphQLResolveInfoWithCacheControl
+  extends Omit<GraphQLResolveInfo, 'cacheControl'> {
+  // Why the Omit above? If you happen to have AS2 `apollo-cache-control` or AS3
+  // `apollo-server-core` in your TypeScript build, then there's an ambient
+  // `declare module` floating around that monkey-patches GraphQLResolveInfo to
+  // have a cacheControl field. This led to lots of problems, which is why in
+  // AS4 we're moving towards the approach in this file where don't assume every
+  // GraphQLResolveInfo is a GraphQLResolveInfoWithCacheControl. The AS3 type is
+  // very slightly incompatible with the type in the file, since we changed
+  // CacheScope to be a union of strings rather than an enum. They have the same
+  // runtime representation so it's safe to ignore, but in order for the
+  // `extends` to not error out if you're building with the old ambient
+  // definition floating around too, we need the Omit.
+  cacheControl: ResolveInfoCacheControl;
+}
+
+/** Given an `info` resolver argument, returns the cacheControl field if it
+ * exists and appears to be from Apollo Server 3 or newer; returns null
+ * otherwise.*/
+export function maybeCacheControlFromInfo(
+  info: GraphQLResolveInfo,
+): ResolveInfoCacheControl | null {
+  if ((info as any).cacheControl?.cacheHint?.restrict) {
+    return (info as any).cacheControl;
+  }
+  return null;
+}
+
+/** Given an `info` resolver argument, returns the cacheControl field if it
+ * exists and appears to be from Apollo Server 3 or newer; throws
+ * otherwise.*/
+export function cacheControlFromInfo(
+  info: GraphQLResolveInfo,
+): ResolveInfoCacheControl {
+  if (!('cacheControl' in info)) {
+    throw new Error(
+      'The `info` argument does not appear to have a cacheControl field. ' +
+        "Check that you are using Apollo Server 3 or newer and that you aren't using " +
+        'ApolloServerPluginCacheControlDisabled.',
+    );
+  }
+  if (!(info as any).cacheControl?.cacheHint?.restrict) {
+    throw new Error(
+      'The `info` argument has a cacheControl field but it does not appear to be from Apollo' +
+        "Server 3 or newer. Check that you are using Apollo Server 3 or newer and that you aren't using " +
+        'ApolloServerPluginCacheControlDisabled.',
+    );
+  }
+  return (info as any).cacheControl;
+}

node_modules/@apollo/protobufjs/LICENSE

@@ -0,0 +1,39 @@
+This license applies to all parts of protobuf.js except those files
+either explicitly including or referencing a different license or
+located in a directory containing a different LICENSE file.
+
+---
+
+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.
+
+---
+
+Code generated by the command line utilities is owned by the owner
+of the input file used when generating it. This code is not
+standalone and requires a support library to be linked with it. This
+support library is itself covered by the above license.

node_modules/@apollo/protobufjs/README.md

@@ -0,0 +1,909 @@
+<h1><p align="center"><img alt="protobuf.js" src="https://github.com/dcodeIO/protobuf.js/raw/master/pbjs.png" width="120" height="104" /></p></h1>
+<p align="center"><a href="https://npmjs.org/package/protobufjs"><img src="https://img.shields.io/npm/v/protobufjs.svg" alt=""></a> <a href="https://travis-ci.org/dcodeIO/protobuf.js"><img src="https://travis-ci.org/dcodeIO/protobuf.js.svg?branch=master" alt=""></a> <a href="https://npmjs.org/package/protobufjs"><img src="https://img.shields.io/npm/dm/protobufjs.svg" alt=""></a> <a href="https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=dcode%40dcode.io&item_name=Open%20Source%20Software%20Donation&item_number=dcodeIO%2Fprotobuf.js"><img alt="donate ❤" src="https://img.shields.io/badge/donate-❤-ff2244.svg"></a></p>
+
+**Protocol Buffers** are a language-neutral, platform-neutral, extensible way of serializing structured data for use in communications protocols, data storage, and more, originally designed at Google ([see](https://developers.google.com/protocol-buffers/)).
+
+**protobuf.js** is a pure JavaScript implementation with [TypeScript](https://www.typescriptlang.org) support for [node.js](https://nodejs.org) and the browser. It's easy to use, blazingly fast and works out of the box with [.proto](https://developers.google.com/protocol-buffers/docs/proto) files!
+
+Apollo GraphQL fork
+-------------------
+We have forked the [source repo](https://github.com/dcodeIO/protobuf.js) because we need to make changes to the package 
+for use in Apollo Server.
+
+Version 1.0.0 was forked from `master` which contained version 6.8.8 plus a few unreleased commits. [sha](https://github.com/protobufjs/protobuf.js/commit/4d490eb1bf71f5c5c4c9d253a2ffd36edea12386)
+
+
+Contents
+--------
+
+* [Installation](#installation)<br />
+  How to include protobuf.js in your project.
+
+* [Usage](#usage)<br />
+  A brief introduction to using the toolset.
+
+  * [Valid Message](#valid-message)
+  * [Toolset](#toolset)<br />
+
+* [Examples](#examples)<br />
+  A few examples to get you started.
+
+  * [Using .proto files](#using-proto-files)
+  * [Using JSON descriptors](#using-json-descriptors)
+  * [Using reflection only](#using-reflection-only)
+  * [Using custom classes](#using-custom-classes)
+  * [Using services](#using-services)
+  * [Usage with TypeScript](#usage-with-typescript)<br />
+
+* [Command line](#command-line)<br />
+  How to use the command line utility.
+
+  * [pbjs for JavaScript](#pbjs-for-javascript)
+  * [pbts for TypeScript](#pbts-for-typescript)
+  * [Reflection vs. static code](#reflection-vs-static-code)
+  * [Command line API](#command-line-api)<br />
+
+* [Additional documentation](#additional-documentation)<br />
+  A list of available documentation resources.
+
+* [Performance](#performance)<br />
+  A few internals and a benchmark on performance.
+
+* [Compatibility](#compatibility)<br />
+  Notes on compatibility regarding browsers and optional libraries.
+
+* [Building](#building)<br />
+  How to build the library and its components yourself.
+
+Installation
+---------------
+
+### node.js
+
+```
+$> npm install @apollo/protobufjs [--save --save-prefix=~]
+```
+
+```js
+var protobuf = require("@apollo/protobufjs");
+```
+
+**Note** that this library's versioning scheme is not semver-compatible for historical reasons. For guaranteed backward compatibility, always depend on `~6.A.B` instead of `^6.A.B` (hence the `--save-prefix` above).
+
+### Browsers
+
+Development:
+
+```
+<script src="//cdn.rawgit.com/dcodeIO/protobuf.js/6.X.X/dist/protobuf.js"></script>
+```
+
+Production:
+
+```
+<script src="//cdn.rawgit.com/dcodeIO/protobuf.js/6.X.X/dist/protobuf.min.js"></script>
+```
+
+**Remember** to replace the version tag with the exact [release](https://github.com/dcodeIO/protobuf.js/tags) your project depends upon.
+
+The library supports CommonJS and AMD loaders and also exports globally as `protobuf`.
+
+### Distributions
+
+Where bundle size is a factor, there are additional stripped-down versions of the [full library][dist-full] (~19kb gzipped) available that exclude certain functionality:
+
+* When working with JSON descriptors (i.e. generated by [pbjs](#pbjs-for-javascript)) and/or reflection only, see the [light library][dist-light] (~16kb gzipped) that excludes the parser. CommonJS entry point is:
+
+  ```js
+  var protobuf = require("@apollo/protobufjs/light");
+  ```
+
+* When working with statically generated code only, see the [minimal library][dist-minimal] (~6.5kb gzipped) that also excludes reflection. CommonJS entry point is:
+
+  ```js
+  var protobuf = require("@apollo/protobufjs/minimal");
+  ```
+
+[dist-full]: https://github.com/dcodeIO/protobuf.js/tree/master/dist
+[dist-light]: https://github.com/dcodeIO/protobuf.js/tree/master/dist/light
+[dist-minimal]: https://github.com/dcodeIO/protobuf.js/tree/master/dist/minimal
+
+Usage
+-----
+
+Because JavaScript is a dynamically typed language, protobuf.js introduces the concept of a **valid message** in order to provide the best possible [performance](#performance) (and, as a side product, proper typings):
+
+### Valid message
+
+> A valid message is an object (1) not missing any required fields and (2) exclusively composed of JS types understood by the wire format writer.
+
+There are two possible types of valid messages and the encoder is able to work with both of these for convenience:
+
+* **Message instances** (explicit instances of message classes with default values on their prototype) always (have to) satisfy the requirements of a valid message by design and
+* **Plain JavaScript objects** that just so happen to be composed in a way satisfying the requirements of a valid message as well.
+
+In a nutshell, the wire format writer understands the following types:
+
+| Field type | Expected JS type (create, encode) | Conversion (fromObject)
+|------------|-----------------------------------|------------------------
+| s-/u-/int32<br />s-/fixed32 | `number` (32 bit integer) | <code>value &#124; 0</code> if signed<br />`value >>> 0` if unsigned
+| s-/u-/int64<br />s-/fixed64 | `Long`-like (optimal)<br />`number` (53 bit integer) | `Long.fromValue(value)` with long.js<br />`parseInt(value, 10)` otherwise
+| float<br />double | `number` | `Number(value)`
+| bool | `boolean` | `Boolean(value)`
+| string | `string` | `String(value)`
+| bytes | `Uint8Array` (optimal)<br />`Buffer` (optimal under node)<br />`Array.<number>` (8 bit integers) | `base64.decode(value)` if a `string`<br />`Object` with non-zero `.length` is assumed to be buffer-like
+| enum | `number` (32 bit integer) | Looks up the numeric id if a `string`
+| message | Valid message | `Message.fromObject(value)`
+
+* Explicit `undefined` and `null` are considered as not set if the field is optional.
+* Repeated fields are `Array.<T>`.
+* Map fields are `Object.<string,T>` with the key being the string representation of the respective value or an 8 characters long binary hash string for `Long`-likes.
+* Types marked as *optimal* provide the best performance because no conversion step (i.e. number to low and high bits or base64 string to buffer) is required.
+
+### Toolset
+
+With that in mind and again for performance reasons, each message class provides a distinct set of methods with each method doing just one thing. This avoids unnecessary assertions / redundant operations where performance is a concern but also forces a user to perform verification (of plain JavaScript objects that *might* just so happen to be a valid message) explicitly where necessary - for example when dealing with user input.
+
+**Note** that `Message` below refers to any message class.
+
+* **Message.verify**(message: `Object`): `null|string`<br />
+  verifies that a **plain JavaScript object** satisfies the requirements of a valid message and thus can be encoded without issues. Instead of throwing, it returns the error message as a string, if any.
+
+  ```js
+  var payload = "invalid (not an object)";
+  var err = AwesomeMessage.verify(payload);
+  if (err)
+    throw Error(err);
+  ```
+
+* **Message.encode**(message: `Message|Object` [, writer: `Writer`]): `Writer`<br />
+  encodes a **message instance** or valid **plain JavaScript object**. This method does not implicitly verify the message and it's up to the user to make sure that the payload is a valid message.
+
+  ```js
+  var buffer = AwesomeMessage.encode(message).finish();
+  ```
+
+* **Message.encodeDelimited**(message: `Message|Object` [, writer: `Writer`]): `Writer`<br />
+  works like `Message.encode` but additionally prepends the length of the message as a varint.
+
+* **Message.decode**(reader: `Reader|Uint8Array`): `Message`<br />
+  decodes a buffer to a **message instance**. If required fields are missing, it throws a `util.ProtocolError` with an `instance` property set to the so far decoded message. If the wire format is invalid, it throws an `Error`.
+
+  ```js
+  try {
+    var decodedMessage = AwesomeMessage.decode(buffer);
+  } catch (e) {
+      if (e instanceof protobuf.util.ProtocolError) {
+        // e.instance holds the so far decoded message with missing required fields
+      } else {
+        // wire format is invalid
+      }
+  }
+  ```
+
+* **Message.decodeDelimited**(reader: `Reader|Uint8Array`): `Message`<br />
+  works like `Message.decode` but additionally reads the length of the message prepended as a varint.
+
+* **Message.create**(properties: `Object`): `Message`<br />
+  creates a new **message instance** from a set of properties that satisfy the requirements of a valid message. Where applicable, it is recommended to prefer `Message.create` over `Message.fromObject` because it doesn't perform possibly redundant conversion.
+
+  ```js
+  var message = AwesomeMessage.create({ awesomeField: "AwesomeString" });
+  ```
+
+* **Message.fromObject**(object: `Object`): `Message`<br />
+  converts any non-valid **plain JavaScript object** to a **message instance** using the conversion steps outlined within the table above.
+
+  ```js
+  var message = AwesomeMessage.fromObject({ awesomeField: 42 });
+  // converts awesomeField to a string
+  ```
+
+* **Message.toObject**(message: `Message` [, options: `ConversionOptions`]): `Object`<br />
+  converts a **message instance** to an arbitrary **plain JavaScript object** for interoperability with other libraries or storage. The resulting plain JavaScript object *might* still satisfy the requirements of a valid message depending on the actual conversion options specified, but most of the time it does not.
+
+  ```js
+  var object = AwesomeMessage.toObject(message, {
+    enums: String,  // enums as string names
+    longs: String,  // longs as strings (requires long.js)
+    bytes: String,  // bytes as base64 encoded strings
+    defaults: true, // includes default values
+    arrays: true,   // populates empty arrays (repeated fields) even if defaults=false
+    objects: true,  // populates empty objects (map fields) even if defaults=false
+    oneofs: true    // includes virtual oneof fields set to the present field's name
+  });
+  ```
+
+For reference, the following diagram aims to display relationships between the different methods and the concept of a valid message:
+
+<p align="center"><img alt="Toolset Diagram" src="https://protobufjs.github.io/protobuf.js/toolset.svg" /></p>
+
+> In other words: `verify` indicates that calling `create` or `encode` directly on the plain object will [result in a valid message respectively] succeed. `fromObject`, on the other hand, does conversion from a broader range of plain objects to create valid messages. ([ref](https://github.com/dcodeIO/protobuf.js/issues/748#issuecomment-291925749))
+
+Examples
+--------
+
+### Using .proto files
+
+It is possible to load existing .proto files using the full library, which parses and compiles the definitions to ready to use (reflection-based) message classes:
+
+```protobuf
+// awesome.proto
+package awesomepackage;
+syntax = "proto3";
+
+message AwesomeMessage {
+    string awesome_field = 1; // becomes awesomeField
+}
+```
+
+```js
+protobuf.load("awesome.proto", function(err, root) {
+    if (err)
+        throw err;
+
+    // Obtain a message type
+    var AwesomeMessage = root.lookupType("awesomepackage.AwesomeMessage");
+
+    // Exemplary payload
+    var payload = { awesomeField: "AwesomeString" };
+
+    // Verify the payload if necessary (i.e. when possibly incomplete or invalid)
+    var errMsg = AwesomeMessage.verify(payload);
+    if (errMsg)
+        throw Error(errMsg);
+
+    // Create a new message
+    var message = AwesomeMessage.create(payload); // or use .fromObject if conversion is necessary
+
+    // Encode a message to an Uint8Array (browser) or Buffer (node)
+    var buffer = AwesomeMessage.encode(message).finish();
+    // ... do something with buffer
+
+    // Decode an Uint8Array (browser) or Buffer (node) to a message
+    var message = AwesomeMessage.decode(buffer);
+    // ... do something with message
+
+    // If the application uses length-delimited buffers, there is also encodeDelimited and decodeDelimited.
+
+    // Maybe convert the message back to a plain object
+    var object = AwesomeMessage.toObject(message, {
+        longs: String,
+        enums: String,
+        bytes: String,
+        // see ConversionOptions
+    });
+});
+```
+
+Additionally, promise syntax can be used by omitting the callback, if preferred:
+
+```js
+protobuf.load("awesome.proto")
+    .then(function(root) {
+       ...
+    });
+```
+
+### Using JSON descriptors
+
+The library utilizes JSON descriptors that are equivalent to a .proto definition. For example, the following is identical to the .proto definition seen above:
+
+```json
+// awesome.json
+{
+  "nested": {
+    "AwesomeMessage": {
+      "fields": {
+        "awesomeField": {
+          "type": "string",
+          "id": 1
+        }
+      }
+    }
+  }
+}
+```
+
+JSON descriptors closely resemble the internal reflection structure:
+
+| Type (T)           | Extends            | Type-specific properties
+|--------------------|--------------------|-------------------------
+| *ReflectionObject* |                    | options
+| *Namespace*        | *ReflectionObject* | nested
+| Root               | *Namespace*        | **nested**
+| Type               | *Namespace*        | **fields**
+| Enum               | *ReflectionObject* | **values**
+| Field              | *ReflectionObject* | rule, **type**, **id**
+| MapField           | Field              | **keyType**
+| OneOf              | *ReflectionObject* | **oneof** (array of field names)
+| Service            | *Namespace*        | **methods**
+| Method             | *ReflectionObject* | type, **requestType**, **responseType**, requestStream, responseStream
+
+* **Bold properties** are required. *Italic types* are abstract.
+* `T.fromJSON(name, json)` creates the respective reflection object from a JSON descriptor
+* `T#toJSON()` creates a JSON descriptor from the respective reflection object (its name is used as the key within the parent)
+
+Exclusively using JSON descriptors instead of .proto files enables the use of just the light library (the parser isn't required in this case).
+
+A JSON descriptor can either be loaded the usual way:
+
+```js
+protobuf.load("awesome.json", function(err, root) {
+    if (err) throw err;
+
+    // Continue at "Obtain a message type" above
+});
+```
+
+Or it can be loaded inline:
+
+```js
+var jsonDescriptor = require("./awesome.json"); // exemplary for node
+
+var root = protobuf.Root.fromJSON(jsonDescriptor);
+
+// Continue at "Obtain a message type" above
+```
+
+### Using reflection only
+
+Both the full and the light library include full reflection support. One could, for example, define the .proto definitions seen in the examples above using just reflection:
+
+```js
+...
+var Root  = protobuf.Root,
+    Type  = protobuf.Type,
+    Field = protobuf.Field;
+
+var AwesomeMessage = new Type("AwesomeMessage").add(new Field("awesomeField", 1, "string"));
+
+var root = new Root().define("awesomepackage").add(AwesomeMessage);
+
+// Continue at "Create a new message" above
+...
+```
+
+Detailed information on the reflection structure is available within the [API documentation](#additional-documentation).
+
+### Using custom classes
+
+Message classes can also be extended with custom functionality and it is also possible to register a custom constructor with a reflected message type:
+
+```js
+...
+
+// Define a custom constructor
+function AwesomeMessage(properties) {
+    // custom initialization code
+    ...
+}
+
+// Register the custom constructor with its reflected type (*)
+root.lookupType("awesomepackage.AwesomeMessage").ctor = AwesomeMessage;
+
+// Define custom functionality
+AwesomeMessage.customStaticMethod = function() { ... };
+AwesomeMessage.prototype.customInstanceMethod = function() { ... };
+
+// Continue at "Create a new message" above
+```
+
+(*) Besides referencing its reflected type through `AwesomeMessage.$type` and `AwesomeMesage#$type`, the respective custom class is automatically populated with:
+
+* `AwesomeMessage.create`
+* `AwesomeMessage.encode` and `AwesomeMessage.encodeDelimited`
+* `AwesomeMessage.decode` and `AwesomeMessage.decodeDelimited`
+* `AwesomeMessage.verify`
+* `AwesomeMessage.fromObject`, `AwesomeMessage.toObject` and `AwesomeMessage#toJSON`
+
+Afterwards, decoded messages of this type are `instanceof AwesomeMessage`.
+
+Alternatively, it is also possible to reuse and extend the internal constructor if custom initialization code is not required:
+
+```js
+...
+
+// Reuse the internal constructor
+var AwesomeMessage = root.lookupType("awesomepackage.AwesomeMessage").ctor;
+
+// Define custom functionality
+AwesomeMessage.customStaticMethod = function() { ... };
+AwesomeMessage.prototype.customInstanceMethod = function() { ... };
+
+// Continue at "Create a new message" above
+```
+
+### Using services
+
+The library also supports consuming services but it doesn't make any assumptions about the actual transport channel. Instead, a user must provide a suitable RPC implementation, which is an asynchronous function that takes the reflected service method, the binary request and a node-style callback as its parameters:
+
+```js
+function rpcImpl(method, requestData, callback) {
+    // perform the request using an HTTP request or a WebSocket for example
+    var responseData = ...;
+    // and call the callback with the binary response afterwards:
+    callback(null, responseData);
+}
+```
+
+Below is a working example with a typescript implementation using grpc npm package.
+```ts
+const grpc = require('grpc')
+
+const Client = grpc.makeGenericClientConstructor({})
+const client = new Client(
+  grpcServerUrl,
+  grpc.credentials.createInsecure()
+)
+
+const rpcImpl = function(method, requestData, callback) {
+  client.makeUnaryRequest(
+    method.name,
+    arg => arg,
+    arg => arg,
+    requestData,
+    callback
+  )
+}
+```
+
+Example:
+
+```protobuf
+// greeter.proto
+syntax = "proto3";
+
+service Greeter {
+    rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+message HelloRequest {
+    string name = 1;
+}
+
+message HelloReply {
+    string message = 1;
+}
+```
+
+```js
+...
+var Greeter = root.lookup("Greeter");
+var greeter = Greeter.create(/* see above */ rpcImpl, /* request delimited? */ false, /* response delimited? */ false);
+
+greeter.sayHello({ name: 'you' }, function(err, response) {
+    console.log('Greeting:', response.message);
+});
+```
+
+Services also support promises:
+
+```js
+greeter.sayHello({ name: 'you' })
+    .then(function(response) {
+        console.log('Greeting:', response.message);
+    });
+```
+
+There is also an [example for streaming RPC](https://github.com/dcodeIO/protobuf.js/blob/master/examples/streaming-rpc.js).
+
+Note that the service API is meant for clients. Implementing a server-side endpoint pretty much always requires transport channel (i.e. http, websocket, etc.) specific code with the only common denominator being that it decodes and encodes messages.
+
+### Usage with TypeScript
+
+The library ships with its own [type definitions](https://github.com/dcodeIO/protobuf.js/blob/master/index.d.ts) and modern editors like [Visual Studio Code](https://code.visualstudio.com/) will automatically detect and use them for code completion.
+
+The npm package depends on [@types/long](https://www.npmjs.com/package/@types/long) because of `Long`. If you are not building for node and/or not using long.js, it should be safe to exclude them manually.
+
+#### Using the JS API
+
+The API shown above works pretty much the same with TypeScript. However, because everything is typed, accessing fields on instances of dynamically generated message classes requires either using bracket-notation (i.e. `message["awesomeField"]`) or explicit casts. Alternatively, it is possible to use a [typings file generated for its static counterpart](#pbts-for-typescript).
+
+```ts
+import { load } from "@apollo/protobufjs"; // respectively "./node_modules/protobufjs"
+
+load("awesome.proto", function(err, root) {
+  if (err)
+    throw err;
+
+  // example code
+  const AwesomeMessage = root.lookupType("awesomepackage.AwesomeMessage");
+
+  let message = AwesomeMessage.create({ awesomeField: "hello" });
+  console.log(`message = ${JSON.stringify(message)}`);
+
+  let buffer = AwesomeMessage.encode(message).finish();
+  console.log(`buffer = ${Array.prototype.toString.call(buffer)}`);
+
+  let decoded = AwesomeMessage.decode(buffer);
+  console.log(`decoded = ${JSON.stringify(decoded)}`);
+});
+```
+
+#### Using generated static code
+
+If you generated static code to `bundle.js` using the CLI and its type definitions to `bundle.d.ts`, then you can just do:
+
+```ts
+import { AwesomeMessage } from "./bundle.js";
+
+// example code
+let message = AwesomeMessage.create({ awesomeField: "hello" });
+let buffer  = AwesomeMessage.encode(message).finish();
+let decoded = AwesomeMessage.decode(buffer);
+```
+
+#### Using decorators
+
+The library also includes an early implementation of [decorators](https://www.typescriptlang.org/docs/handbook/decorators.html).
+
+**Note** that decorators are an experimental feature in TypeScript and that declaration order is important depending on the JS target. For example, `@Field.d(2, AwesomeArrayMessage)` requires that `AwesomeArrayMessage` has been defined earlier when targeting `ES5`.
+
+```ts
+import { Message, Type, Field, OneOf } from "@apollo/protobufjs/light"; // respectively "./node_modules/protobufjs/light.js"
+
+export class AwesomeSubMessage extends Message<AwesomeSubMessage> {
+
+  @Field.d(1, "string")
+  public awesomeString: string;
+
+}
+
+export enum AwesomeEnum {
+  ONE = 1,
+  TWO = 2
+}
+
+@Type.d("SuperAwesomeMessage")
+export class AwesomeMessage extends Message<AwesomeMessage> {
+
+  @Field.d(1, "string", "optional", "awesome default string")
+  public awesomeField: string;
+
+  @Field.d(2, AwesomeSubMessage)
+  public awesomeSubMessage: AwesomeSubMessage;
+
+  @Field.d(3, AwesomeEnum, "optional", AwesomeEnum.ONE)
+  public awesomeEnum: AwesomeEnum;
+
+  @OneOf.d("awesomeSubMessage", "awesomeEnum")
+  public which: string;
+
+}
+
+// example code
+let message = new AwesomeMessage({ awesomeField: "hello" });
+let buffer  = AwesomeMessage.encode(message).finish();
+let decoded = AwesomeMessage.decode(buffer);
+```
+
+Supported decorators are:
+
+* **Type.d(typeName?: `string`)** &nbsp; *(optional)*<br />
+  annotates a class as a protobuf message type. If `typeName` is not specified, the constructor's runtime function name is used for the reflected type.
+
+* **Field.d&lt;T>(fieldId: `number`, fieldType: `string | Constructor<T>`, fieldRule?: `"optional" | "required" | "repeated"`, defaultValue?: `T`)**<br />
+  annotates a property as a protobuf field with the specified id and protobuf type.
+
+* **MapField.d&lt;T extends { [key: string]: any }>(fieldId: `number`, fieldKeyType: `string`, fieldValueType. `string | Constructor<{}>`)**<br />
+  annotates a property as a protobuf map field with the specified id, protobuf key and value type.
+
+* **OneOf.d&lt;T extends string>(...fieldNames: `string[]`)**<br />
+  annotates a property as a protobuf oneof covering the specified fields.
+
+Other notes:
+
+* Decorated types reside in `protobuf.roots["decorated"]` using a flat structure, so no duplicate names.
+* Enums are copied to a reflected enum with a generic name on decorator evaluation because referenced enum objects have no runtime name the decorator could use.
+* Default values must be specified as arguments to the decorator instead of using a property initializer for proper prototype behavior.
+* Property names on decorated classes must not be renamed on compile time (i.e. by a minifier) because decorators just receive the original field name as a string.
+
+**ProTip!** Not as pretty, but you can [use decorators in plain JavaScript](https://github.com/dcodeIO/protobuf.js/blob/master/examples/js-decorators.js) as well.
+
+Command line
+------------
+
+**Note** that moving the CLI to [its own package](./cli) is a work in progress. At the moment, it's still part of the main package.
+
+The command line interface (CLI) can be used to translate between file formats and to generate static code as well as TypeScript definitions.
+
+### pbjs for JavaScript
+
+```
+Translates between file formats and generates static code.
+
+  -t, --target     Specifies the target format. Also accepts a path to require a custom target.
+
+                   json          JSON representation
+                   json-module   JSON representation as a module
+                   proto2        Protocol Buffers, Version 2
+                   proto3        Protocol Buffers, Version 3
+                   static        Static code without reflection (non-functional on its own)
+                   static-module Static code without reflection as a module
+
+  -p, --path       Adds a directory to the include path.
+
+  -o, --out        Saves to a file instead of writing to stdout.
+
+  --sparse         Exports only those types referenced from a main file (experimental).
+
+  Module targets only:
+
+  -w, --wrap       Specifies the wrapper to use. Also accepts a path to require a custom wrapper.
+
+                   default   Default wrapper supporting both CommonJS and AMD
+                   commonjs  CommonJS wrapper
+                   amd       AMD wrapper
+                   es6       ES6 wrapper (implies --es6)
+                   closure   A closure adding to protobuf.roots where protobuf is a global
+
+  -r, --root       Specifies an alternative protobuf.roots name.
+
+  -l, --lint       Linter configuration. Defaults to protobuf.js-compatible rules:
+
+                   eslint-disable block-scoped-var, no-redeclare, no-control-regex, no-prototype-builtins
+
+  --es6            Enables ES6 syntax (const/let instead of var)
+
+  Proto sources only:
+
+  --keep-case      Keeps field casing instead of converting to camel case.
+
+  Static targets only:
+
+  --no-create      Does not generate create functions used for reflection compatibility.
+  --no-encode      Does not generate encode functions.
+  --no-decode      Does not generate decode functions.
+  --no-verify      Does not generate verify functions.
+  --no-convert     Does not generate convert functions like from/toObject
+  --no-delimited   Does not generate delimited encode/decode functions.
+  --no-beautify    Does not beautify generated code.
+  --no-comments    Does not output any JSDoc comments.
+
+  --force-long     Enforces the use of 'Long' for s-/u-/int64 and s-/fixed64 fields.
+  --force-number   Enforces the use of 'number' for s-/u-/int64 and s-/fixed64 fields.
+  --force-message  Enforces the use of message instances instead of plain objects.
+
+usage: pbjs [options] file1.proto file2.json ...  (or pipe)  other | pbjs [options] -
+```
+
+For production environments it is recommended to bundle all your .proto files to a single .json file, which minimizes the number of network requests and avoids any parser overhead (hint: works with just the **light** library):
+
+```
+$> pbjs -t json file1.proto file2.proto > bundle.json
+```
+
+Now, either include this file in your final bundle:
+
+```js
+var root = protobuf.Root.fromJSON(require("./bundle.json"));
+```
+
+or load it the usual way:
+
+```js
+protobuf.load("bundle.json", function(err, root) {
+    ...
+});
+```
+
+Generated static code, on the other hand, works with just the **minimal** library. For example
+
+```
+$> pbjs -t static-module -w commonjs -o compiled.js file1.proto file2.proto
+```
+
+will generate static code for definitions within `file1.proto` and `file2.proto` to a CommonJS module `compiled.js`.
+
+**ProTip!** Documenting your .proto files with `/** ... */`-blocks or (trailing) `/// ...` lines translates to generated static code.
+
+
+### pbts for TypeScript
+
+```
+Generates TypeScript definitions from annotated JavaScript files.
+
+  -o, --out       Saves to a file instead of writing to stdout.
+
+  -g, --global    Name of the global object in browser environments, if any.
+
+  --no-comments   Does not output any JSDoc comments.
+
+  Internal flags:
+
+  -n, --name      Wraps everything in a module of the specified name.
+
+  -m, --main      Whether building the main library without any imports.
+
+usage: pbts [options] file1.js file2.js ...  (or)  other | pbts [options] -
+```
+
+Picking up on the example above, the following not only generates static code to a CommonJS module `compiled.js` but also its respective TypeScript definitions to `compiled.d.ts`:
+
+```
+$> pbjs -t static-module -w commonjs -o compiled.js file1.proto file2.proto
+$> pbts -o compiled.d.ts compiled.js
+```
+
+Additionally, TypeScript definitions of static modules are compatible with their reflection-based counterparts (i.e. as exported by JSON modules), as long as the following conditions are met:
+
+1. Instead of using `new SomeMessage(...)`, always use `SomeMessage.create(...)` because reflection objects do not provide a constructor.
+2. Types, services and enums must start with an uppercase letter to become available as properties of the reflected types as well (i.e. to be able to use `MyMessage.MyEnum` instead of `root.lookup("MyMessage.MyEnum")`).
+
+For example, the following generates a JSON module `bundle.js` and a `bundle.d.ts`, but no static code:
+
+```
+$> pbjs -t json-module -w commonjs -o bundle.js file1.proto file2.proto
+$> pbjs -t static-module file1.proto file2.proto | pbts -o bundle.d.ts -
+```
+
+### Reflection vs. static code
+
+While using .proto files directly requires the full library respectively pure reflection/JSON the light library, pretty much all code but the relatively short descriptors is shared.
+
+Static code, on the other hand, requires just the minimal library, but generates additional source code without any reflection features. This also implies that there is a break-even point where statically generated code becomes larger than descriptor-based code once the amount of code generated exceeds the size of the full respectively light library.
+
+There is no significant difference performance-wise as the code generated statically is pretty much the same as generated at runtime and both are largely interchangeable as seen in the previous section.
+
+| Source | Library | Advantages | Tradeoffs
+|--------|---------|------------|-----------
+| .proto | full    | Easily editable<br />Interoperability with other libraries<br />No compile step | Some parsing and possibly network overhead
+| JSON   | light   | Easily editable<br />No parsing overhead<br />Single bundle (no network overhead) | protobuf.js specific<br />Has a compile step
+| static | minimal | Works where `eval` access is restricted<br />Fully documented<br />Small footprint for small protos | Can be hard to edit<br />No reflection<br />Has a compile step
+
+### Command line API
+
+Both utilities can be used programmatically by providing command line arguments and a callback to their respective `main` functions:
+
+```js
+var pbjs = require("@apollo/protobufjs/cli/pbjs"); // or require("@apollo/protobufjs/cli").pbjs / .pbts
+
+pbjs.main([ "--target", "json-module", "path/to/myproto.proto" ], function(err, output) {
+    if (err)
+        throw err;
+    // do something with output
+});
+```
+
+Additional documentation
+------------------------
+
+#### Protocol Buffers
+* [Google's Developer Guide](https://developers.google.com/protocol-buffers/docs/overview)
+
+#### protobuf.js
+* [API Documentation](https://protobufjs.github.io/protobuf.js)
+* [CHANGELOG](https://github.com/dcodeIO/protobuf.js/blob/master/CHANGELOG.md)
+* [Frequently asked questions](https://github.com/dcodeIO/protobuf.js/wiki) on our wiki
+
+#### Community
+* [Questions and answers](http://stackoverflow.com/search?tab=newest&q=protobuf.js) on StackOverflow
+
+Performance
+-----------
+The package includes a benchmark that compares protobuf.js performance to native JSON (as far as this is possible) and [Google's JS implementation](https://github.com/google/protobuf/tree/master/js). On an i7-2600K running node 6.9.1 it yields:
+
+```
+benchmarking encoding performance ...
+
+protobuf.js (reflect) x 541,707 ops/sec ±1.13% (87 runs sampled)
+protobuf.js (static) x 548,134 ops/sec ±1.38% (89 runs sampled)
+JSON (string) x 318,076 ops/sec ±0.63% (93 runs sampled)
+JSON (buffer) x 179,165 ops/sec ±2.26% (91 runs sampled)
+google-protobuf x 74,406 ops/sec ±0.85% (86 runs sampled)
+
+   protobuf.js (static) was fastest
+  protobuf.js (reflect) was 0.9% ops/sec slower (factor 1.0)
+          JSON (string) was 41.5% ops/sec slower (factor 1.7)
+          JSON (buffer) was 67.6% ops/sec slower (factor 3.1)
+        google-protobuf was 86.4% ops/sec slower (factor 7.3)
+
+benchmarking decoding performance ...
+
+protobuf.js (reflect) x 1,383,981 ops/sec ±0.88% (93 runs sampled)
+protobuf.js (static) x 1,378,925 ops/sec ±0.81% (93 runs sampled)
+JSON (string) x 302,444 ops/sec ±0.81% (93 runs sampled)
+JSON (buffer) x 264,882 ops/sec ±0.81% (93 runs sampled)
+google-protobuf x 179,180 ops/sec ±0.64% (94 runs sampled)
+
+  protobuf.js (reflect) was fastest
+   protobuf.js (static) was 0.3% ops/sec slower (factor 1.0)
+          JSON (string) was 78.1% ops/sec slower (factor 4.6)
+          JSON (buffer) was 80.8% ops/sec slower (factor 5.2)
+        google-protobuf was 87.0% ops/sec slower (factor 7.7)
+
+benchmarking combined performance ...
+
+protobuf.js (reflect) x 275,900 ops/sec ±0.78% (90 runs sampled)
+protobuf.js (static) x 290,096 ops/sec ±0.96% (90 runs sampled)
+JSON (string) x 129,381 ops/sec ±0.77% (90 runs sampled)
+JSON (buffer) x 91,051 ops/sec ±0.94% (90 runs sampled)
+google-protobuf x 42,050 ops/sec ±0.85% (91 runs sampled)
+
+   protobuf.js (static) was fastest
+  protobuf.js (reflect) was 4.7% ops/sec slower (factor 1.0)
+          JSON (string) was 55.3% ops/sec slower (factor 2.2)
+          JSON (buffer) was 68.6% ops/sec slower (factor 3.2)
+        google-protobuf was 85.5% ops/sec slower (factor 6.9)
+```
+
+These results are achieved by
+
+* generating type-specific encoders, decoders, verifiers and converters at runtime
+* configuring the reader/writer interface according to the environment
+* using node-specific functionality where beneficial and, of course
+* avoiding unnecessary operations through splitting up [the toolset](#toolset).
+
+You can also run [the benchmark](https://github.com/dcodeIO/protobuf.js/blob/master/bench/index.js) ...
+
+```
+$> npm run bench
+```
+
+and [the profiler](https://github.com/dcodeIO/protobuf.js/blob/master/bench/prof.js) yourself (the latter requires a recent version of node):
+
+```
+$> npm run prof <encode|decode|encode-browser|decode-browser> [iterations=10000000]
+```
+
+Note that as of this writing, the benchmark suite performs significantly slower on node 7.2.0 compared to 6.9.1 because moths.
+
+Compatibility
+-------------
+
+* Works in all modern and not-so-modern browsers except IE8.
+* Because the internals of this package do not rely on `google/protobuf/descriptor.proto`, options are parsed and presented literally.
+* If typed arrays are not supported by the environment, plain arrays will be used instead.
+* Support for pre-ES5 environments (except IE8) can be achieved by [using a polyfill](https://github.com/dcodeIO/protobuf.js/blob/master/scripts/polyfill.js).
+* Support for [Content Security Policy](https://w3c.github.io/webappsec-csp/)-restricted environments (like Chrome extensions without [unsafe-eval](https://developer.chrome.com/extensions/contentSecurityPolicy#relaxing-eval)) can be achieved by generating and using static code instead.
+* If a proper way to work with 64 bit values (uint64, int64 etc.) is required, just install [long.js](https://github.com/dcodeIO/long.js) alongside this library. All 64 bit numbers will then be returned as a `Long` instance instead of a possibly unsafe JavaScript number ([see](https://github.com/dcodeIO/long.js)).
+* For descriptor.proto interoperability, see [ext/descriptor](https://github.com/dcodeIO/protobuf.js/tree/master/ext/descriptor)
+
+Building
+--------
+
+To build the library or its components yourself, clone it from GitHub and install the development dependencies:
+
+```
+$> git clone https://github.com/dcodeIO/protobuf.js.git
+$> cd protobuf.js
+$> npm install
+```
+
+Building the respective development and production versions with their respective source maps to `dist/`:
+
+```
+$> npm run build
+```
+
+Building the documentation to `docs/`:
+
+```
+$> npm run docs
+```
+
+Building the TypeScript definition to `index.d.ts`:
+
+```
+$> npm run types
+```
+
+### Browserify integration
+
+By default, protobuf.js integrates into any browserify build-process without requiring any optional modules. Hence:
+
+* If int64 support is required, explicitly require the `long` module somewhere in your project as it will be excluded otherwise. This assumes that a global `require` function is present that protobuf.js can call to obtain the long module.
+
+  If there is no global `require` function present after bundling, it's also possible to assign the long module programmatically:
+
+  ```js
+  var Long = ...;
+
+  protobuf.util.Long = Long;
+  protobuf.configure();
+  ```
+
+* If you have any special requirements, there is [the bundler](https://github.com/dcodeIO/protobuf.js/blob/master/scripts/bundle.js) for reference.
+
+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)

node_modules/@apollo/protobufjs/bin/pbjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+var path = require("path"),
+    cli  = require(path.join(__dirname, "..", "cli", "pbjs.js"));
+var ret  = cli.main(process.argv.slice(2));
+if (typeof ret === 'number')
+    process.exit(ret);

node_modules/@apollo/protobufjs/bin/pbts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+var path = require("path"),
+    cli  = require(path.join(__dirname, "..", "cli", "pbts.js"));
+var ret  = cli.main(process.argv.slice(2));
+if (typeof ret === 'number')
+    process.exit(ret);

node_modules/@apollo/protobufjs/cli/LICENSE

@@ -0,0 +1,33 @@
+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.
+
+---
+
+Code generated by the command line utilities is owned by the owner
+of the input file used when generating it. This code is not
+standalone and requires a support library to be linked with it. This
+support library is itself covered by the above license.

node_modules/@apollo/protobufjs/cli/README.md

@@ -0,0 +1,11 @@
+protobufjs-cli
+==============
+[![npm](https://img.shields.io/npm/v/protobufjscli.svg)](https://www.npmjs.com/package/protobufjs-cli)
+
+Command line interface (CLI) for [protobuf.js](https://github.com/dcodeIO/protobuf.js). Translates between file formats and generates static code as well as TypeScript definitions.
+
+* [CLI Documentation](https://github.com/dcodeIO/protobuf.js#command-line)
+
+**Note** that moving the CLI to its own package is a work in progress. At the moment, it's still part of the main package.
+
+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)

node_modules/@apollo/protobufjs/cli/bin/pbjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+var path = require("path"),
+    cli  = require(path.join(__dirname, "..", "pbjs.js"));
+var ret  = cli.main(process.argv.slice(2));
+if (typeof ret === 'number')
+    process.exit(ret);

node_modules/@apollo/protobufjs/cli/bin/pbts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+var path = require("path"),
+    cli  = require(path.join(__dirname, "..", "pbts.js"));
+var ret  = cli.main(process.argv.slice(2));
+if (typeof ret === 'number')
+    process.exit(ret);

node_modules/@apollo/protobufjs/cli/index.d.ts

@@ -0,0 +1,3 @@
+import * as pbjs from "./pbjs.js";
+import * as pbts from "./pbts.js";
+export { pbjs, pbts };

node_modules/@apollo/protobufjs/cli/index.js

@@ -0,0 +1,3 @@
+"use strict";
+exports.pbjs = require("./pbjs");
+exports.pbts = require("./pbts");

node_modules/@apollo/protobufjs/cli/lib/tsd-jsdoc.json

@@ -0,0 +1,18 @@
+{
+    "tags": {
+        "allowUnknownTags": false
+    },
+    "plugins": [
+        "./tsd-jsdoc/plugin"
+    ],
+    "opts": {
+        "encoding"      : "utf8",
+        "recurse"       : true,
+        "lenient"       : true,
+        "template"      : "./tsd-jsdoc",
+
+        "private"       : false,
+        "comments"      : true,
+        "destination"   : false
+    }
+}

node_modules/@apollo/protobufjs/cli/lib/tsd-jsdoc/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2016 Chad Engler
+
+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.

node_modules/@apollo/protobufjs/cli/lib/tsd-jsdoc/README.md

@@ -0,0 +1,23 @@
+protobuf.js fork of tsd-jsdoc
+=============================
+
+This is a modified version of [tsd-jsdoc](https://github.com/englercj/tsd-jsdoc) v1.0.1 for use with protobuf.js, parked here so we can process issues and pull requests. The ultimate goal is to switch back to the a recent version of tsd-jsdoc once it meets our needs.
+
+Options
+-------
+
+* **module: `string`**<br />
+  Wraps everything in a module of the specified name.
+
+* **private: `boolean`**<br />
+  Includes private members when set to `true`.
+
+* **comments: `boolean`**<br />
+  Skips comments when explicitly set to `false`.
+
+* **destination: `string|boolean`**<br />
+  Saves to the specified destination file or to console when set to `false`.
+
+Setting options on the command line
+-----------------------------------
+Providing `-q, --query <queryString>` on the command line will set respectively override existing options. Example: `-q module=protobufjs`

node_modules/@apollo/protobufjs/cli/lib/tsd-jsdoc/plugin.js

@@ -0,0 +1,21 @@
+"use strict";
+exports.defineTags = function(dictionary) {
+
+    dictionary.defineTag("template", {
+        mustHaveValue: true,
+        canHaveType: false,
+        canHaveName: false,
+        onTagged: function(doclet, tag) {
+            (doclet.templates || (doclet.templates = [])).push(tag.text);
+        }
+    });
+
+    dictionary.defineTag("tstype", {
+        mustHaveValue: true,
+        canHaveType: false,
+        canHaveName: false,
+        onTagged: function(doclet, tag) {
+            doclet.tsType = tag.text;
+        }
+    });
+};

node_modules/@apollo/protobufjs/cli/lib/tsd-jsdoc/publish.js

@@ -0,0 +1,693 @@
+"use strict";
+
+var fs = require("fs");
+
+// output stream
+var out = null;
+
+// documentation data
+var data = null;
+
+// already handled objects, by name
+var seen = {};
+
+// indentation level
+var indent = 0;
+
+// whether indent has been written for the current line yet
+var indentWritten = false;
+
+// provided options
+var options = {};
+
+// queued interfaces
+var queuedInterfaces = [];
+
+// whether writing the first line
+var firstLine = true;
+
+// JSDoc hook
+exports.publish = function publish(taffy, opts) {
+    options = opts || {};
+
+    // query overrides options
+    if (options.query)
+        Object.keys(options.query).forEach(function(key) {
+            if (key !== "query")
+                switch (options[key] = options.query[key]) {
+                    case "true":
+                        options[key] = true;
+                        break;
+                    case "false":
+                        options[key] = false;
+                        break;
+                    case "null":
+                        options[key] = null;
+                        break;
+                }
+        });
+
+    // remove undocumented
+    taffy({ undocumented: true }).remove();
+    taffy({ ignore: true }).remove();
+    taffy({ inherited: true }).remove();
+
+    // remove private
+    if (!options.private)
+        taffy({ access: "private" }).remove();
+
+    // setup output
+    out = options.destination
+        ? fs.createWriteStream(options.destination)
+        : process.stdout;
+
+    try {
+        // setup environment
+        data = taffy().get();
+        indent = 0;
+        indentWritten = false;
+        firstLine = true;
+
+        // wrap everything in a module if configured
+        if (options.module) {
+            writeln("export = ", options.module, ";");
+            writeln();
+            writeln("declare namespace ", options.module, " {");
+            writeln();
+            ++indent;
+        }
+
+        // handle all
+        getChildrenOf(undefined).forEach(function(child) {
+            handleElement(child, null);
+        });
+
+        // process queued
+        while (queuedInterfaces.length) {
+            var element = queuedInterfaces.shift();
+            begin(element);
+            writeInterface(element);
+            writeln(";");
+        }
+
+        // end wrap
+        if (options.module) {
+            --indent;
+            writeln("}");
+        }
+
+        // close file output
+        if (out !== process.stdout)
+            out.end();
+
+    } finally {
+        // gc environment objects
+        out = data = null;
+        seen = options = {};
+        queuedInterfaces = [];
+    }
+};
+
+//
+// Utility
+//
+
+// writes one or multiple strings
+function write() {
+    var s = Array.prototype.slice.call(arguments).join("");
+    if (!indentWritten) {
+        for (var i = 0; i < indent; ++i)
+            s = "    " + s;
+        indentWritten = true;
+    }
+    out.write(s);
+    firstLine = false;
+}
+
+// writes zero or multiple strings, followed by a new line
+function writeln() {
+    var s = Array.prototype.slice.call(arguments).join("");
+    if (s.length)
+        write(s, "\n");
+    else if (!firstLine)
+        out.write("\n");
+    indentWritten = false;
+}
+
+var keepTags = [
+    "param",
+    "returns",
+    "throws",
+    "see"
+];
+
+// parses a comment into text and tags
+function parseComment(comment) {
+    var lines = comment.replace(/^ *\/\*\* *|^ *\*\/| *\*\/ *$|^ *\* */mg, "").trim().split(/\r?\n|\r/g); // property.description has just "\r" ?!
+    var desc;
+    var text = [];
+    var tags = null;
+    for (var i = 0; i < lines.length; ++i) {
+        var match = /^@(\w+)\b/.exec(lines[i]);
+        if (match) {
+            if (!tags) {
+                tags = [];
+                desc = text;
+            }
+            text = [];
+            tags.push({ name: match[1], text: text });
+            lines[i] = lines[i].substring(match[1].length + 1).trim();
+        }
+        if (lines[i].length || text.length)
+            text.push(lines[i]);
+    }
+    return {
+        text: desc || text,
+        tags: tags || []
+    };
+}
+
+// writes a comment
+function writeComment(comment, otherwiseNewline) {
+    if (!comment || options.comments === false) {
+        if (otherwiseNewline)
+            writeln();
+        return;
+    }
+    if (typeof comment !== "object")
+        comment = parseComment(comment);
+    comment.tags = comment.tags.filter(function(tag) {
+        return keepTags.indexOf(tag.name) > -1 && (tag.name !== "returns" || tag.text[0] !== "{undefined}");
+    });
+    writeln();
+    if (!comment.tags.length && comment.text.length < 2) {
+        writeln("/** " + comment.text[0] + " */");
+        return;
+    }
+    writeln("/**");
+    comment.text.forEach(function(line) {
+        if (line.length)
+            writeln(" * ", line);
+        else
+            writeln(" *");
+    });
+    comment.tags.forEach(function(tag) {
+        var started = false;
+        if (tag.text.length) {
+            tag.text.forEach(function(line, i) {
+                if (i > 0)
+                    write(" * ");
+                else if (tag.name !== "throws")
+                    line = line.replace(/^\{[^\s]*} ?/, "");
+                if (!line.length)
+                    return;
+                if (!started) {
+                    write(" * @", tag.name, " ");
+                    started = true;
+                }
+                writeln(line);
+            });
+        }
+    });
+    writeln(" */");
+}
+
+// recursively replaces all occurencies of re's match
+function replaceRecursive(name, re, fn) {
+    var found;
+
+    function replacer() {
+        found = true;
+        return fn.apply(null, arguments);
+    }
+
+    do {
+        found = false;
+        name = name.replace(re, replacer);
+    } while (found);
+    return name;
+}
+
+// tests if an element is considered to be a class or class-like
+function isClassLike(element) {
+    return isClass(element) || isInterface(element);
+}
+
+// tests if an element is considered to be a class
+function isClass(element) {
+    return element && element.kind === "class";
+}
+
+// tests if an element is considered to be an interface
+function isInterface(element) {
+    return element && (element.kind === "interface" || element.kind === "mixin");
+}
+
+// tests if an element is considered to be a namespace
+function isNamespace(element) {
+    return element && (element.kind === "namespace" || element.kind === "module");
+}
+
+// gets all children of the specified parent
+function getChildrenOf(parent) {
+    var memberof = parent ? parent.longname : undefined;
+    return data.filter(function(element) {
+        return element.memberof === memberof;
+    });
+}
+
+// gets the literal type of an element
+function getTypeOf(element) {
+    if (element.tsType)
+        return element.tsType.replace(/\r?\n|\r/g, "\n");
+    var name = "any";
+    var type = element.type;
+    if (type && type.names && type.names.length) {
+        if (type.names.length === 1)
+            name = element.type.names[0].trim();
+        else
+            name = "(" + element.type.names.join("|") + ")";
+    } else
+        return name;
+
+    // Replace catchalls with any
+    name = name.replace(/\*|\bmixed\b/g, "any");
+
+    // Ensure upper case Object for map expressions below
+    name = name.replace(/\bobject\b/g, "Object");
+
+    // Correct Something.<Something> to Something<Something>
+    name = replaceRecursive(name, /\b(?!Object|Array)([\w$]+)\.<([^>]*)>/gi, function($0, $1, $2) {
+        return $1 + "<" + $2 + ">";
+    });
+
+    // Replace Array.<string> with string[]
+    name = replaceRecursive(name, /\bArray\.?<([^>]*)>/gi, function($0, $1) {
+        return $1 + "[]";
+    });
+
+    // Replace Object.<string,number> with { [k: string]: number }
+    name = replaceRecursive(name, /\bObject\.?<([^,]*), *([^>]*)>/gi, function($0, $1, $2) {
+        return "{ [k: " + $1 + "]: " + $2 + " }";
+    });
+
+    // Replace functions (there are no signatures) with Function
+    name = name.replace(/\bfunction(?:\(\))?\b/g, "Function");
+
+    // Convert plain Object back to just object
+    name = name.replace(/\b(Object\b(?!\.))/g, function($0, $1) {
+        return $1.toLowerCase();
+    });
+
+    return name;
+}
+
+// begins writing the definition of the specified element
+function begin(element, is_interface) {
+    if (!seen[element.longname]) {
+        if (isClass(element)) {
+            var comment = parseComment(element.comment);
+            var classdesc = comment.tags.find(function(tag) { return tag.name === "classdesc"; });
+            if (classdesc) {
+                comment.text = classdesc.text;
+                comment.tags = [];
+            }
+            writeComment(comment, true);
+        } else
+            writeComment(element.comment, is_interface || isClassLike(element) || isNamespace(element) || element.isEnum || element.scope === "global");
+        seen[element.longname] = element;
+    } else
+        writeln();
+    if (element.scope !== "global" || options.module)
+        return;
+    write("export ");
+}
+
+// writes the function signature describing element
+function writeFunctionSignature(element, isConstructor, isTypeDef) {
+    write("(");
+
+    var params = {};
+
+    // this type
+    if (element.this)
+        params["this"] = {
+            type: element.this.replace(/^{|}$/g, ""),
+            optional: false
+        };
+
+    // parameter types
+    if (element.params)
+        element.params.forEach(function(param) {
+            var path = param.name.split(/\./g);
+            if (path.length === 1)
+                params[param.name] = {
+                    type: getTypeOf(param),
+                    variable: param.variable === true,
+                    optional: param.optional === true,
+                    defaultValue: param.defaultvalue // Not used yet (TODO)
+                };
+            else // Property syntax (TODO)
+                params[path[0]].type = "{ [k: string]: any }";
+        });
+
+    var paramNames = Object.keys(params);
+    paramNames.forEach(function(name, i) {
+        var param = params[name];
+        var type = param.type;
+        if (param.variable) {
+            name = "..." + name;
+            type = param.type.charAt(0) === "(" ? "any[]" : param.type + "[]";
+        }
+        write(name, !param.variable && param.optional ? "?: " : ": ", type);
+        if (i < paramNames.length - 1)
+            write(", ");
+    });
+
+    write(")");
+
+    // return type
+    if (!isConstructor) {
+        write(isTypeDef ? " => " : ": ");
+        var typeName;
+        if (element.returns && element.returns.length && (typeName = getTypeOf(element.returns[0])) !== "undefined")
+            write(typeName);
+        else
+            write("void");
+    }
+}
+
+// writes (a typedef as) an interface
+function writeInterface(element) {
+    write("interface ", element.name);
+    writeInterfaceBody(element);
+    writeln();
+}
+
+function writeInterfaceBody(element) {
+    writeln("{");
+    ++indent;
+    if (element.tsType)
+        writeln(element.tsType.replace(/\r?\n|\r/g, "\n"));
+    else if (element.properties && element.properties.length)
+        element.properties.forEach(writeProperty);
+    --indent;
+    write("}");
+}
+
+function writeProperty(property, declare) {
+    writeComment(property.description);
+    if (declare)
+        write("let ");
+    write(property.name);
+    if (property.optional)
+        write("?");
+    writeln(": ", getTypeOf(property), ";");
+}
+
+//
+// Handlers
+//
+
+// handles a single element of any understood type
+function handleElement(element, parent) {
+    if (element.scope === "inner")
+        return false;
+
+    if (element.optional !== true && element.type && element.type.names && element.type.names.length) {
+        for (var i = 0; i < element.type.names.length; i++) {
+            if (element.type.names[i].toLowerCase() === "undefined") {
+                // This element is actually optional. Set optional to true and
+                // remove the 'undefined' type
+                element.optional = true;
+                element.type.names.splice(i, 1);
+                i--;
+            }
+        }
+    }
+
+    if (seen[element.longname])
+        return true;
+    if (isClassLike(element))
+        handleClass(element, parent);
+    else switch (element.kind) {
+        case "module":
+        case "namespace":
+            handleNamespace(element, parent);
+            break;
+        case "constant":
+        case "member":
+            handleMember(element, parent);
+            break;
+        case "function":
+            handleFunction(element, parent);
+            break;
+        case "typedef":
+            handleTypeDef(element, parent);
+            break;
+        case "package":
+            break;
+    }
+    seen[element.longname] = element;
+    return true;
+}
+
+// handles (just) a namespace
+function handleNamespace(element/*, parent*/) {
+    var children = getChildrenOf(element);
+    if (!children.length)
+        return;
+    var first = true;
+    if (element.properties)
+        element.properties.forEach(function(property) {
+            if (!/^[$\w]+$/.test(property.name)) // incompatible in namespace
+                return;
+            if (first) {
+                begin(element);
+                writeln("namespace ", element.name, " {");
+                ++indent;
+                first = false;
+            }
+            writeProperty(property, true);
+        });
+    children.forEach(function(child) {
+        if (child.scope === "inner" || seen[child.longname])
+            return;
+        if (first) {
+            begin(element);
+            writeln("namespace ", element.name, " {");
+            ++indent;
+            first = false;
+        }
+        handleElement(child, element);
+    });
+    if (!first) {
+        --indent;
+        writeln("}");
+    }
+}
+
+// a filter function to remove any module references
+function notAModuleReference(ref) {
+    return ref.indexOf("module:") === -1;
+}
+
+// handles a class or class-like
+function handleClass(element, parent) {
+    var is_interface = isInterface(element);
+    begin(element, is_interface);
+    if (is_interface)
+        write("interface ");
+    else {
+        if (element.virtual)
+            write("abstract ");
+        write("class ");
+    }
+    write(element.name);
+    if (element.templates && element.templates.length)
+        write("<", element.templates.join(", "), ">");
+    write(" ");
+
+    // extended classes
+    if (element.augments) {
+        var augments = element.augments.filter(notAModuleReference);
+        if (augments.length)
+            write("extends ", augments[0], " ");
+    }
+
+    // implemented interfaces
+    var impls = [];
+    if (element.implements)
+        Array.prototype.push.apply(impls, element.implements);
+    if (element.mixes)
+        Array.prototype.push.apply(impls, element.mixes);
+    impls = impls.filter(notAModuleReference);
+    if (impls.length)
+        write("implements ", impls.join(", "), " ");
+
+    writeln("{");
+    ++indent;
+
+    if (element.tsType)
+        writeln(element.tsType.replace(/\r?\n|\r/g, "\n"));
+
+    // constructor
+    if (!is_interface && !element.virtual)
+        handleFunction(element, parent, true);
+
+    // properties
+    if (is_interface && element.properties)
+        element.properties.forEach(function(property) {
+            writeProperty(property);
+        });
+
+    // class-compatible members
+    var incompatible = [];
+    getChildrenOf(element).forEach(function(child) {
+        if (isClassLike(child) || child.kind === "module" || child.kind === "typedef" || child.isEnum) {
+            incompatible.push(child);
+            return;
+        }
+        handleElement(child, element);
+    });
+
+    --indent;
+    writeln("}");
+
+    // class-incompatible members
+    if (incompatible.length) {
+        writeln();
+        if (element.scope === "global" && !options.module)
+            write("export ");
+        writeln("namespace ", element.name, " {");
+        ++indent;
+        incompatible.forEach(function(child) {
+            handleElement(child, element);
+        });
+        --indent;
+        writeln("}");
+    }
+}
+
+// handles a namespace or class member
+function handleMember(element, parent) {
+    begin(element);
+
+    if (element.isEnum) {
+        var stringEnum = false;
+        element.properties.forEach(function(property) {
+            if (isNaN(property.defaultvalue)) {
+                stringEnum = true;
+            }
+        });
+        if (stringEnum) {
+            writeln("type ", element.name, " =");
+            ++indent;
+            element.properties.forEach(function(property, i) {
+                write(i === 0 ? "" : "| ", JSON.stringify(property.defaultvalue));
+            });
+            --indent;
+            writeln(";");
+        } else {
+            writeln("enum ", element.name, " {");
+            ++indent;
+            element.properties.forEach(function(property, i) {
+                write(property.name);
+                if (property.defaultvalue !== undefined)
+                    write(" = ", JSON.stringify(property.defaultvalue));
+                if (i < element.properties.length - 1)
+                    writeln(",");
+                else
+                    writeln();
+            });
+            --indent;
+            writeln("}");
+        }
+
+    } else {
+
+        var inClass = isClassLike(parent);
+        if (inClass) {
+            write(element.access || "public", " ");
+            if (element.scope === "static")
+                write("static ");
+            if (element.readonly)
+                write("readonly ");
+        } else
+            write(element.kind === "constant" ? "const " : "let ");
+
+        write(element.name);
+        if (element.optional)
+            write("?");
+        write(": ");
+
+        if (element.type && element.type.names && /^Object\b/i.test(element.type.names[0]) && element.properties) {
+            writeln("{");
+            ++indent;
+            element.properties.forEach(function(property, i) {
+                writeln(JSON.stringify(property.name), ": ", getTypeOf(property), i < element.properties.length - 1 ? "," : "");
+            });
+            --indent;
+            writeln("};");
+        } else
+            writeln(getTypeOf(element), ";");
+    }
+}
+
+// handles a function or method
+function handleFunction(element, parent, isConstructor) {
+    var insideClass = true;
+    if (isConstructor) {
+        writeComment(element.comment);
+        write("constructor");
+    } else {
+        begin(element);
+        insideClass = isClassLike(parent);
+        if (insideClass) {
+            write(element.access || "public", " ");
+            if (element.scope === "static")
+                write("static ");
+        } else
+            write("function ");
+        write(element.name);
+        if (element.templates && element.templates.length)
+            write("<", element.templates.join(", "), ">");
+    }
+    writeFunctionSignature(element, isConstructor, false);
+    writeln(";");
+    if (!insideClass)
+        handleNamespace(element);
+}
+
+// handles a type definition (not a real type)
+function handleTypeDef(element, parent) {
+    if (isInterface(element)) {
+        if (isClassLike(parent))
+            queuedInterfaces.push(element);
+        else {
+            begin(element);
+            writeInterface(element);
+        }
+    } else {
+        writeComment(element.comment, true);
+        write("type ", element.name);
+        if (element.templates && element.templates.length)
+            write("<", element.templates.join(", "), ">");
+        write(" = ");
+        if (element.tsType)
+            write(element.tsType.replace(/\r?\n|\r/g, "\n"));
+        else {
+            var type = getTypeOf(element);
+            if (element.type && element.type.names.length === 1 && element.type.names[0] === "function")
+                writeFunctionSignature(element, false, true);
+            else if (type === "object") {
+                if (element.properties && element.properties.length)
+                    writeInterfaceBody(element);
+                else
+                    write("{}");
+            } else
+                write(type);
+        }
+        writeln(";");
+    }
+}

node_modules/@apollo/protobufjs/cli/package.json

@@ -0,0 +1,7 @@
+{
+  "version": "6.7.0",
+  "dependencies": {
+    "jsdoc": "^3.6.3",
+    "minimist": "^1.2.0"
+  }
+}

node_modules/@apollo/protobufjs/cli/package.standalone.json

@@ -0,0 +1,32 @@
+{
+  "name": "protobufjs-cli",
+  "description": "Translates between file formats and generates static code as well as TypeScript definitions.",
+  "version": "6.7.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",
+  "bin": {
+    "pbjs": "bin/pbjs",
+    "pbts": "bin/pbts"
+  },
+  "peerDependencies": {
+    "@apollo/protobufjs": "~1.0.5"
+  },
+  "dependencies": {
+    "chalk": "^1.1.3",
+    "escodegen": "^1.8.1",
+    "espree": "^3.1.3",
+    "estraverse": "^4.2.0",
+    "glob": "^7.1.1",
+    "jsdoc": "^3.4.2",
+    "minimist": "^1.2.0",
+    "semver": "^5.3.0",
+    "tmp": "0.0.31",
+    "uglify-js": "^2.8.15"
+  }
+}

node_modules/@apollo/protobufjs/cli/pbjs.d.ts

@@ -0,0 +1,9 @@
+type pbjsCallback = (err: Error|null, output?: string) => void;
+
+/**
+ * Runs pbjs programmatically.
+ * @param {string[]} args Command line arguments
+ * @param {function(?Error, string=)} [callback] Optional completion callback
+ * @returns {number|undefined} Exit code, if known
+ */
+export function main(args: string[], callback?: pbjsCallback): number|undefined;

node_modules/@apollo/protobufjs/cli/pbjs.js

@@ -0,0 +1,331 @@
+"use strict";
+var path     = require("path"),
+    fs       = require("fs"),
+    pkg      = require("./package.json"),
+    util     = require("./util");
+
+util.setup();
+
+var protobuf = require(util.pathToProtobufJs),
+    minimist = require("minimist"),
+    chalk    = require("chalk"),
+    glob     = require("glob");
+
+var targets  = util.requireAll("./targets");
+
+/**
+ * Runs pbjs programmatically.
+ * @param {string[]} args Command line arguments
+ * @param {function(?Error, string=)} [callback] Optional completion callback
+ * @returns {number|undefined} Exit code, if known
+ */
+exports.main = function main(args, callback) {
+    var lintDefault = "eslint-disable " + [
+        "block-scoped-var",
+        "id-length",
+        "no-control-regex",
+        "no-magic-numbers",
+        "no-prototype-builtins",
+        "no-redeclare",
+        "no-shadow",
+        "no-var",
+        "sort-vars"
+    ].join(", ");
+    var argv = minimist(args, {
+        alias: {
+            target: "t",
+            out: "o",
+            path: "p",
+            wrap: "w",
+            root: "r",
+            lint: "l",
+            // backward compatibility:
+            "force-long": "strict-long",
+            "force-message": "strict-message"
+        },
+        string: [ "target", "out", "path", "wrap", "dependency", "root", "lint" ],
+        boolean: [ "create", "encode", "decode", "verify", "convert", "from-object", "delimited", "beautify", "comments", "es6", "sparse", "keep-case", "force-long", "force-number", "force-enum-string", "force-message" ],
+        default: {
+            target: "json",
+            create: true,
+            encode: true,
+            decode: true,
+            verify: true,
+            convert: true,
+            "from-object": true,
+            delimited: true,
+            beautify: true,
+            comments: true,
+            es6: null,
+            lint: lintDefault,
+            "keep-case": false,
+            "force-long": false,
+            "force-number": false,
+            "force-enum-string": false,
+            "force-message": false
+        }
+    });
+
+    var target = targets[argv.target],
+        files  = argv._,
+        paths  = typeof argv.path === "string" ? [ argv.path ] : argv.path || [];
+
+    // alias hyphen args in camel case
+    Object.keys(argv).forEach(function(key) {
+        var camelKey = key.replace(/-([a-z])/g, function($0, $1) { return $1.toUpperCase(); });
+        if (camelKey !== key)
+            argv[camelKey] = argv[key];
+    });
+
+    // protobuf.js package directory contains additional, otherwise non-bundled google types
+    paths.push(path.relative(process.cwd(), path.join(__dirname, "..")) || ".");
+
+    if (!files.length) {
+        var descs = Object.keys(targets).filter(function(key) { return !targets[key].private; }).map(function(key) {
+            return "                   " + util.pad(key, 14, true) + targets[key].description;
+        });
+        if (callback)
+            callback(Error("usage")); // eslint-disable-line callback-return
+        else
+            process.stderr.write([
+                "protobuf.js v" + pkg.version + " CLI for JavaScript",
+                "",
+                chalk.bold.white("Translates between file formats and generates static code."),
+                "",
+                "  -t, --target     Specifies the target format. Also accepts a path to require a custom target.",
+                "",
+                descs.join("\n"),
+                "",
+                "  -p, --path       Adds a directory to the include path.",
+                "",
+                "  -o, --out        Saves to a file instead of writing to stdout.",
+                "",
+                "  --sparse         Exports only those types referenced from a main file (experimental).",
+                "",
+                chalk.bold.gray("  Module targets only:"),
+                "",
+                "  -w, --wrap       Specifies the wrapper to use. Also accepts a path to require a custom wrapper.",
+                "",
+                "                   default   Default wrapper supporting both CommonJS and AMD",
+                "                   commonjs  CommonJS wrapper",
+                "                   amd       AMD wrapper",
+                "                   es6       ES6 wrapper (implies --es6)",
+                "                   closure   A closure adding to protobuf.roots where protobuf is a global",
+                "",
+                "  --dependency     Specifies which version of protobuf to require. Accepts any valid module id",
+                "",
+                "  -r, --root       Specifies an alternative protobuf.roots name.",
+                "",
+                "  -l, --lint       Linter configuration. Defaults to protobuf.js-compatible rules:",
+                "",
+                "                   " + lintDefault,
+                "",
+                "  --es6            Enables ES6 syntax (const/let instead of var)",
+                "",
+                chalk.bold.gray("  Proto sources only:"),
+                "",
+                "  --keep-case      Keeps field casing instead of converting to camel case.",
+                "",
+                chalk.bold.gray("  Static targets only:"),
+                "",
+                "  --no-create      Does not generate create functions used for reflection compatibility.",
+                "  --no-encode      Does not generate encode functions.",
+                "  --no-decode      Does not generate decode functions.",
+                "  --no-verify      Does not generate verify functions.",
+                "  --no-convert     Does not generate convert functions like from/toObject",
+                "  --no-from-object Does not generate fromObject",
+                "  --no-delimited   Does not generate delimited encode/decode functions.",
+                "  --no-beautify    Does not beautify generated code.",
+                "  --no-comments    Does not output any JSDoc comments.",
+                "",
+                "  --force-long     Enfores the use of 'Long' for s-/u-/int64 and s-/fixed64 fields.",
+                "  --force-number   Enfores the use of 'number' for s-/u-/int64 and s-/fixed64 fields.",
+                "  --force-message  Enfores the use of message instances instead of plain objects.",
+                "",
+                "usage: " + chalk.bold.green("pbjs") + " [options] file1.proto file2.json ..." + chalk.gray("  (or pipe)  ") + "other | " + chalk.bold.green("pbjs") + " [options] -",
+                ""
+            ].join("\n"));
+        return 1;
+    }
+
+    if (typeof argv["strict-long"] === "boolean")
+        argv["force-long"] = argv["strict-long"];
+
+    // Resolve glob expressions
+    for (var i = 0; i < files.length;) {
+        if (glob.hasMagic(files[i])) {
+            var matches = glob.sync(files[i]);
+            Array.prototype.splice.apply(files, [i, 1].concat(matches));
+            i += matches.length;
+        } else
+            ++i;
+    }
+
+    // Require custom target
+    if (!target)
+        target = require(path.resolve(process.cwd(), argv.target));
+
+    var root = new protobuf.Root();
+
+    var mainFiles = [];
+
+    // Search include paths when resolving imports
+    root.resolvePath = function pbjsResolvePath(origin, target) {
+        var normOrigin = protobuf.util.path.normalize(origin),
+            normTarget = protobuf.util.path.normalize(target);
+        if (!normOrigin)
+            mainFiles.push(normTarget);
+
+        var resolved = protobuf.util.path.resolve(normOrigin, normTarget, true);
+        var idx = resolved.lastIndexOf("google/protobuf/");
+        if (idx > -1) {
+            var altname = resolved.substring(idx);
+            if (altname in protobuf.common)
+                resolved = altname;
+        }
+
+        if (fs.existsSync(resolved))
+            return resolved;
+
+        for (var i = 0; i < paths.length; ++i) {
+            var iresolved = protobuf.util.path.resolve(paths[i] + "/", target);
+            if (fs.existsSync(iresolved))
+                return iresolved;
+        }
+
+        return resolved;
+    };
+
+    // Use es6 syntax if not explicitly specified on the command line and the es6 wrapper is used
+    if (argv.wrap === "es6" || argv.es6) {
+        argv.wrap = "es6";
+        argv.es6 = true;
+    }
+
+    var parseOptions = {
+        "keepCase": argv["keep-case"] || false
+    };
+
+    // Read from stdin
+    if (files.length === 1 && files[0] === "-") {
+        var data = [];
+        process.stdin.on("data", function(chunk) {
+            data.push(chunk);
+        });
+        process.stdin.on("end", function() {
+            var source = Buffer.concat(data).toString("utf8");
+            try {
+                if (source.charAt(0) !== "{") {
+                    protobuf.parse.filename = "-";
+                    protobuf.parse(source, root, parseOptions);
+                } else {
+                    var json = JSON.parse(source);
+                    root.setOptions(json.options).addJSON(json);
+                }
+                callTarget();
+            } catch (err) {
+                if (callback) {
+                    callback(err);
+                    return;
+                }
+                throw err;
+            }
+        });
+
+    // Load from disk
+    } else {
+        try {
+            root.loadSync(files, parseOptions).resolveAll(); // sync is deterministic while async is not
+            if (argv.sparse)
+                sparsify(root);
+            callTarget();
+        } catch (err) {
+            if (callback) {
+                callback(err);
+                return undefined;
+            }
+            throw err;
+        }
+    }
+
+    function markReferenced(tobj) {
+        tobj.referenced = true;
+        // also mark a type's fields and oneofs
+        if (tobj.fieldsArray)
+            tobj.fieldsArray.forEach(function(fobj) {
+                fobj.referenced = true;
+            });
+        if (tobj.oneofsArray)
+            tobj.oneofsArray.forEach(function(oobj) {
+                oobj.referenced = true;
+            });
+        // also mark an extension field's extended type, but not its (other) fields
+        if (tobj.extensionField)
+            tobj.extensionField.parent.referenced = true;
+    }
+
+    function sparsify(root) {
+
+        // 1. mark directly or indirectly referenced objects
+        util.traverse(root, function(obj) {
+            if (!obj.filename)
+                return;
+            if (mainFiles.indexOf(obj.filename) > -1)
+                util.traverseResolved(obj, markReferenced);
+        });
+
+        // 2. empty unreferenced objects
+        util.traverse(root, function(obj) {
+            var parent = obj.parent;
+            if (!parent || obj.referenced) // root or referenced
+                return;
+            // remove unreferenced namespaces
+            if (obj instanceof protobuf.Namespace) {
+                var hasReferenced = false;
+                util.traverse(obj, function(iobj) {
+                    if (iobj.referenced)
+                        hasReferenced = true;
+                });
+                if (hasReferenced) { // replace with plain namespace if a namespace subclass
+                    if (obj instanceof protobuf.Type || obj instanceof protobuf.Service) {
+                        var robj = new protobuf.Namespace(obj.name, obj.options);
+                        robj.nested = obj.nested;
+                        parent.add(robj);
+                    }
+                } else // remove completely if nothing inside is referenced
+                    parent.remove(obj);
+
+            // remove everything else unreferenced
+            } else if (!(obj instanceof protobuf.Namespace))
+                parent.remove(obj);
+        });
+
+        // 3. validate that everything is fine
+        root.resolveAll();
+    }
+
+    function callTarget() {
+        target(root, argv, function targetCallback(err, output) {
+            if (err) {
+                if (callback)
+                    return callback(err);
+                throw err;
+            }
+            try {
+                if (argv.out)
+                    fs.writeFileSync(argv.out, output, { encoding: "utf8" });
+                else if (!callback)
+                    process.stdout.write(output, "utf8");
+                return callback
+                    ? callback(null, output)
+                    : undefined;
+            } catch (err) {
+                if (callback)
+                    return callback(err);
+                throw err;
+            }
+        });
+    }
+
+    return undefined;
+};

node_modules/@apollo/protobufjs/cli/pbts.d.ts

@@ -0,0 +1,9 @@
+type pbtsCallback = (err: Error|null, output?: string) => void;
+
+/**
+ * Runs pbts programmatically.
+ * @param {string[]} args Command line arguments
+ * @param {function(?Error, string=)} [callback] Optional completion callback
+ * @returns {number|undefined} Exit code, if known
+ */
+export function main(args: string[], callback?: pbtsCallback): number|undefined;

node_modules/@apollo/protobufjs/cli/pbts.js

@@ -0,0 +1,198 @@
+"use strict";
+var child_process = require("child_process"),
+    path     = require("path"),
+    fs       = require("fs"),
+    pkg      = require("./package.json"),
+    util     = require("./util");
+
+util.setup();
+
+var minimist = require("minimist"),
+    chalk    = require("chalk"),
+    glob     = require("glob"),
+    tmp      = require("tmp");
+
+/**
+ * Runs pbts programmatically.
+ * @param {string[]} args Command line arguments
+ * @param {function(?Error, string=)} [callback] Optional completion callback
+ * @returns {number|undefined} Exit code, if known
+ */
+exports.main = function(args, callback) {
+    var argv = minimist(args, {
+        alias: {
+            name: "n",
+            out : "o",
+            main: "m",
+            global: "g",
+            import: "i"
+        },
+        string: [ "name", "out", "global", "import" ],
+        boolean: [ "comments", "main" ],
+        default: {
+            comments: true,
+            main: false
+        }
+    });
+
+    var files  = argv._;
+
+    if (!files.length) {
+        if (callback)
+            callback(Error("usage")); // eslint-disable-line callback-return
+        else
+            process.stderr.write([
+                "protobuf.js v" + pkg.version + " CLI for TypeScript",
+                "",
+                chalk.bold.white("Generates TypeScript definitions from annotated JavaScript files."),
+                "",
+                "  -o, --out       Saves to a file instead of writing to stdout.",
+                "",
+                "  -g, --global    Name of the global object in browser environments, if any.",
+                "",
+                "  -i, --import    Comma delimited list of imports. Local names will equal camelCase of the basename.",
+                "",
+                "  --no-comments   Does not output any JSDoc comments.",
+                "",
+                chalk.bold.gray("  Internal flags:"),
+                "",
+                "  -n, --name      Wraps everything in a module of the specified name.",
+                "",
+                "  -m, --main      Whether building the main library without any imports.",
+                "",
+                "usage: " + chalk.bold.green("pbts") + " [options] file1.js file2.js ..." + chalk.bold.gray("  (or)  ") + "other | " + chalk.bold.green("pbts") + " [options] -",
+                ""
+            ].join("\n"));
+        return 1;
+    }
+
+    // Resolve glob expressions
+    for (var i = 0; i < files.length;) {
+        if (glob.hasMagic(files[i])) {
+            var matches = glob.sync(files[i]);
+            Array.prototype.splice.apply(files, [i, 1].concat(matches));
+            i += matches.length;
+        } else
+            ++i;
+    }
+
+    var cleanup = [];
+
+    // Read from stdin (to a temporary file)
+    if (files.length === 1 && files[0] === "-") {
+        var data = [];
+        process.stdin.on("data", function(chunk) {
+            data.push(chunk);
+        });
+        process.stdin.on("end", function() {
+            files[0] = tmp.tmpNameSync() + ".js";
+            fs.writeFileSync(files[0], Buffer.concat(data));
+            cleanup.push(files[0]);
+            callJsdoc();
+        });
+
+    // Load from disk
+    } else {
+        callJsdoc();
+    }
+
+    function callJsdoc() {
+
+        // There is no proper API for jsdoc, so this executes the CLI and pipes the output
+        var basedir = path.join(__dirname, ".");
+        var moduleName = argv.name || "null";
+        var nodePath = process.execPath;
+        var cmd = "\"" + nodePath + "\" \"" + require.resolve("jsdoc/jsdoc.js") + "\" -c \"" + path.join(basedir, "lib", "tsd-jsdoc.json") + "\" -q \"module=" + encodeURIComponent(moduleName) + "&comments=" + Boolean(argv.comments) + "\" " + files.map(function(file) { return "\"" + file + "\""; }).join(" ");
+        var child = child_process.exec(cmd, {
+            cwd: process.cwd(),
+            argv0: "node",
+            stdio: "pipe",
+            maxBuffer: 1 << 24 // 16mb
+        });
+        var out = [];
+        var ended = false;
+        var closed = false;
+        child.stdout.on("data", function(data) {
+            out.push(data);
+        });
+        child.stdout.on("end", function() {
+            if (closed) finish();
+            else ended = true;
+        });
+        child.stderr.pipe(process.stderr);
+        child.on("close", function(code) {
+            // clean up temporary files, no matter what
+            try { cleanup.forEach(fs.unlinkSync); } catch(e) {/**/} cleanup = [];
+
+            if (code) {
+                out = out.join("").replace(/\s*JSDoc \d+\.\d+\.\d+ [^$]+/, "");
+                process.stderr.write(out);
+                var err = Error("code " + code);
+                if (callback)
+                    return callback(err);
+                throw err;
+            }
+
+            if (ended) return finish();
+            closed = true;
+            return undefined;
+        });
+
+        function getImportName(importItem) {
+            return path.basename(importItem, ".js").replace(/([-_~.+]\w)/g, function(match) {
+                return match[1].toUpperCase();
+            });
+        }
+
+        function finish() {
+            var output = [];
+            if (argv.main)
+                output.push(
+                    "// DO NOT EDIT! This is a generated file. Edit the JSDoc in src/*.js instead and run 'npm run types'.",
+                    ""
+                );
+
+            if (argv.global)
+                output.push(
+                    "export as namespace " + argv.global + ";",
+                    ""
+                );
+
+            if (!argv.main) {
+                // Ensure we have a usable array of imports
+                var importArray = typeof argv.import === "string" ? argv.import.split(",") : argv.import || [];
+
+                // Build an object of imports and paths
+                var imports = {
+                    $protobuf: "@apollo/protobufjs"
+                };
+                importArray.forEach(function(importItem) {
+                    imports[getImportName(importItem)] = importItem;
+                });
+
+                // Write out the imports
+                Object.keys(imports).forEach(function(key) {
+                    output.push("import * as " + key + " from \"" + imports[key] + "\";");
+                });
+            }
+
+            output = output.join("\n") + "\n" + out.join("");
+
+            try {
+                if (argv.out)
+                    fs.writeFileSync(argv.out, output, { encoding: "utf8" });
+                else if (!callback)
+                    process.stdout.write(output, "utf8");
+                return callback
+                    ? callback(null, output)
+                    : undefined;
+            } catch (err) {
+                if (callback)
+                    return callback(err);
+                throw err;
+            }
+        }
+    }
+
+    return undefined;
+};

node_modules/@apollo/protobufjs/cli/targets/json-module.js

@@ -0,0 +1,38 @@
+"use strict";
+module.exports = json_module;
+
+var util = require("../util");
+
+var protobuf = require("../..");
+
+json_module.description = "JSON representation as a module";
+
+function jsonSafeProp(json) {
+    return json.replace(/^( +)"(\w+)":/mg, function($0, $1, $2) {
+        return protobuf.util.safeProp($2).charAt(0) === "."
+            ? $1 + $2 + ":"
+            : $0;
+    });
+}
+
+function json_module(root, options, callback) {
+    try {
+        var rootProp = protobuf.util.safeProp(options.root || "default");
+        var output = [
+            (options.es6 ? "const" : "var") + " $root = ($protobuf.roots" + rootProp + " || ($protobuf.roots" + rootProp + " = new $protobuf.Root()))\n"
+        ];
+        if (root.options) {
+            var optionsJson = jsonSafeProp(JSON.stringify(root.options, null, 2));
+            output.push(".setOptions(" + optionsJson + ")\n");
+        }
+        var json = jsonSafeProp(JSON.stringify(root.nested, null, 2).trim());
+        output.push(".addJSON(" + json + ");");
+        output = util.wrap(output.join(""), protobuf.util.merge({ dependency: "@apollo/protobufjs/light" }, options));
+        process.nextTick(function() {
+            callback(null, output);
+        });
+    } catch (e) {
+        return callback(e);
+    }
+    return undefined;
+}

node_modules/@apollo/protobufjs/cli/targets/json.js

@@ -0,0 +1,8 @@
+"use strict";
+module.exports = json_target;
+
+json_target.description = "JSON representation";
+
+function json_target(root, options, callback) {
+    callback(null, JSON.stringify(root, null, 2));
+}

node_modules/@apollo/protobufjs/cli/targets/proto.js

@@ -0,0 +1,326 @@
+"use strict";
+module.exports = proto_target;
+
+proto_target.private = true;
+
+var protobuf = require("../..");
+
+var Namespace  = protobuf.Namespace,
+    Enum       = protobuf.Enum,
+    Type       = protobuf.Type,
+    Field      = protobuf.Field,
+    OneOf      = protobuf.OneOf,
+    Service    = protobuf.Service,
+    Method     = protobuf.Method,
+    types      = protobuf.types,
+    util       = protobuf.util;
+
+function underScore(str) {
+    return str.substring(0,1)
+         + str.substring(1)
+               .replace(/([A-Z])(?=[a-z]|$)/g, function($0, $1) { return "_" + $1.toLowerCase(); });
+}
+
+var out = [];
+var indent = 0;
+var first = false;
+var syntax = 3;
+
+function proto_target(root, options, callback) {
+    if (options) {
+        switch (options.syntax) {
+            case undefined:
+            case "proto3":
+            case "3":
+                syntax = 3;
+                break;
+            case "proto2":
+            case "2":
+                syntax = 2;
+                break;
+            default:
+                return callback(Error("invalid syntax: " + options.syntax));
+        }
+    }
+    indent = 0;
+    first = false;
+    try {
+        buildRoot(root);
+        return callback(null, out.join("\n"));
+    } catch (err) {
+        return callback(err);
+    } finally {
+        out = [];
+        syntax = 3;
+    }
+}
+
+function push(line) {
+    if (line === "")
+        out.push("");
+    else {
+        var ind = "";
+        for (var i = 0; i < indent; ++i)
+            ind += "    ";
+        out.push(ind + line);
+    }
+}
+
+function escape(str) {
+    return str.replace(/[\\"']/g, "\\$&")
+              .replace(/\r/g, "\\r")
+              .replace(/\n/g, "\\n")
+              .replace(/\u0000/g, "\\0"); // eslint-disable-line no-control-regex
+}
+
+function value(v) {
+    switch (typeof v) {
+        case "boolean":
+            return v ? "true" : "false";
+        case "number":
+            return v.toString();
+        default:
+            return "\"" + escape(String(v)) + "\"";
+    }
+}
+
+function buildRoot(root) {
+    root.resolveAll();
+    var pkg = [];
+    var ptr = root;
+    var repeat = true;
+    do {
+        var nested = ptr.nestedArray;
+        if (nested.length === 1 && nested[0] instanceof Namespace && !(nested[0] instanceof Type || nested[0] instanceof Service)) {
+            ptr = nested[0];
+            if (ptr !== root)
+                pkg.push(ptr.name);
+        } else
+            repeat = false;
+    } while (repeat);
+    out.push("syntax = \"proto" + syntax + "\";");
+    if (pkg.length)
+        out.push("", "package " + pkg.join(".") + ";");
+
+    buildOptions(ptr);
+    ptr.nestedArray.forEach(build);
+}
+
+function build(object) {
+    if (object instanceof Enum)
+        buildEnum(object);
+    else if (object instanceof Type)
+        buildType(object);
+    else if (object instanceof Field)
+        buildField(object);
+    else if (object instanceof OneOf)
+        buildOneOf(object);
+    else if (object instanceof Service)
+        buildService(object);
+    else if (object instanceof Method)
+        buildMethod(object);
+    else
+        buildNamespace(object);
+}
+
+function buildNamespace(namespace) { // just a namespace, not a type etc.
+    push("");
+    push("message " + namespace.name + " {");
+    ++indent;
+    buildOptions(namespace);
+    consolidateExtends(namespace.nestedArray).remaining.forEach(build);
+    --indent;
+    push("}");
+}
+
+function buildEnum(enm) {
+    push("");
+    push("enum " + enm.name + " {");
+    buildOptions(enm);
+    ++indent; first = true;
+    Object.keys(enm.values).forEach(function(name) {
+        var val = enm.values[name];
+        if (first) {
+            push("");
+            first = false;
+        }
+        push(name + " = " + val + ";");
+    });
+    --indent; first = false;
+    push("}");
+}
+
+function buildRanges(keyword, ranges) {
+    if (ranges && ranges.length) {
+        var parts = [];
+        ranges.forEach(function(range) {
+            if (typeof range === "string")
+                parts.push("\"" + escape(range) + "\"");
+            else if (range[0] === range[1])
+                parts.push(range[0]);
+            else
+                parts.push(range[0] + " to " + (range[1] === 0x1FFFFFFF ? "max" : range[1]));
+        });
+        push("");
+        push(keyword + " " + parts.join(", ") + ";");
+    }
+}
+
+function buildType(type) {
+    if (type.group)
+        return; // built with the sister-field
+    push("");
+    push("message " + type.name + " {");
+    ++indent;
+    buildOptions(type);
+    type.oneofsArray.forEach(build);
+    first = true;
+    type.fieldsArray.forEach(build);
+    consolidateExtends(type.nestedArray).remaining.forEach(build);
+    buildRanges("extensions", type.extensions);
+    buildRanges("reserved", type.reserved);
+    --indent;
+    push("}");
+}
+
+function buildField(field, passExtend) {
+    if (field.partOf || field.declaringField || field.extend !== undefined && !passExtend)
+        return;
+    if (first) {
+        first = false;
+        push("");
+    }
+    if (field.resolvedType && field.resolvedType.group) {
+        buildGroup(field);
+        return;
+    }
+    var sb = [];
+    if (field.map)
+        sb.push("map<" + field.keyType + ", " + field.type + ">");
+    else if (field.repeated)
+        sb.push("repeated", field.type);
+    else if (syntax === 2 || field.parent.group)
+        sb.push(field.required ? "required" : "optional", field.type);
+    else
+        sb.push(field.type);
+    sb.push(underScore(field.name), "=", field.id);
+    var opts = buildFieldOptions(field);
+    if (opts)
+        sb.push(opts);
+    push(sb.join(" ") + ";");
+}
+
+function buildGroup(field) {
+    push(field.rule + " group " + field.resolvedType.name + " = " + field.id + " {");
+    ++indent;
+    buildOptions(field.resolvedType);
+    first = true;
+    field.resolvedType.fieldsArray.forEach(function(field) {
+        buildField(field);
+    });
+    --indent;
+    push("}");
+}
+
+function buildFieldOptions(field) {
+    var keys;
+    if (!field.options || !(keys = Object.keys(field.options)).length)
+        return null;
+    var sb = [];
+    keys.forEach(function(key) {
+        var val = field.options[key];
+        var wireType = types.packed[field.resolvedType instanceof Enum ? "int32" : field.type];
+        switch (key) {
+            case "packed":
+                val = Boolean(val);
+                // skip when not packable or syntax default
+                if (wireType === undefined || syntax === 3 === val)
+                    return;
+                break;
+            case "default":
+                if (syntax === 3)
+                    return;
+                // skip default (resolved) default values
+                if (field.long && !util.longNeq(field.defaultValue, types.defaults[field.type]) || !field.long && field.defaultValue === types.defaults[field.type])
+                    return;
+                // enum defaults specified as strings are type references and not enclosed in quotes
+                if (field.resolvedType instanceof Enum)
+                    break;
+                // otherwise fallthrough
+            default:
+                val = value(val);
+                break;
+        }
+        sb.push(key + "=" + val);
+    });
+    return sb.length
+        ? "[" + sb.join(", ") + "]"
+        : null;
+}
+
+function consolidateExtends(nested) {
+    var ext = {};
+    nested = nested.filter(function(obj) {
+        if (!(obj instanceof Field) || obj.extend === undefined)
+            return true;
+        (ext[obj.extend] || (ext[obj.extend] = [])).push(obj);
+        return false;
+    });
+    Object.keys(ext).forEach(function(extend) {
+        push("");
+        push("extend " + extend + " {");
+        ++indent; first = true;
+        ext[extend].forEach(function(field) {
+            buildField(field, true);
+        });
+        --indent;
+        push("}");
+    });
+    return {
+        remaining: nested
+    };
+}
+
+function buildOneOf(oneof) {
+    push("");
+    push("oneof " + underScore(oneof.name) + " {");
+    ++indent; first = true;
+    oneof.oneof.forEach(function(fieldName) {
+        var field = oneof.parent.get(fieldName);
+        if (first) {
+            first = false;
+            push("");
+        }
+        var opts = buildFieldOptions(field);
+        push(field.type + " " + underScore(field.name) + " = " + field.id + (opts ? " " + opts : "") + ";");
+    });
+    --indent;
+    push("}");
+}
+
+function buildService(service) {
+    push("service " + service.name + " {");
+    ++indent;
+    service.methodsArray.forEach(build);
+    consolidateExtends(service.nestedArray).remaining.forEach(build);
+    --indent;
+    push("}");
+}
+
+function buildMethod(method) {
+    push(method.type + " " + method.name + " (" + (method.requestStream ? "stream " : "") + method.requestType + ") returns (" + (method.responseStream ? "stream " : "") + method.responseType + ");");
+}
+
+function buildOptions(object) {
+    if (!object.options)
+        return;
+    first = true;
+    Object.keys(object.options).forEach(function(key) {
+        if (first) {
+            first = false;
+            push("");
+        }
+        var val = object.options[key];
+        push("option " + key + " = " + JSON.stringify(val) + ";");
+    });
+}

node_modules/@apollo/protobufjs/cli/targets/proto2.js

@@ -0,0 +1,10 @@
+"use strict";
+module.exports = proto2_target;
+
+var protobuf = require("../..");
+
+proto2_target.description = "Protocol Buffers, Version 2";
+
+function proto2_target(root, options, callback) {
+    require("./proto")(root, protobuf.util.merge(options, { syntax: "proto2" }), callback);
+}

node_modules/@apollo/protobufjs/cli/targets/proto3.js

@@ -0,0 +1,10 @@
+"use strict";
+module.exports = proto3_target;
+
+var protobuf = require("../..");
+
+proto3_target.description = "Protocol Buffers, Version 3";
+
+function proto3_target(root, options, callback) {
+    require("./proto")(root, protobuf.util.merge(options, { syntax: "proto3" }), callback);
+}

node_modules/@apollo/protobufjs/cli/targets/static-module.js

@@ -0,0 +1,29 @@
+"use strict";
+module.exports = static_module_target;
+
+// - The default wrapper supports AMD, CommonJS and the global scope (as window.root), in this order.
+// - You can specify a custom wrapper with the --wrap argument.
+// - CommonJS modules depend on the minimal build for reduced package size with browserify.
+// - AMD and global scope depend on the full library for now.
+
+var util = require("../util");
+
+var protobuf = require("../..");
+
+static_module_target.description = "Static code without reflection as a module";
+
+function static_module_target(root, options, callback) {
+    require("./static")(root, options, function(err, output) {
+        if (err) {
+            callback(err);
+            return;
+        }
+        try {
+            output = util.wrap(output, protobuf.util.merge({ dependency: "@apollo/protobufjs/minimal" }, options));
+        } catch (e) {
+            callback(e);
+            return;
+        }
+        callback(null, output);
+    });
+}

node_modules/@apollo/protobufjs/cli/targets/static.js

@@ -0,0 +1,709 @@
+"use strict";
+module.exports = static_target;
+
+var protobuf   = require("../.."),
+    UglifyJS   = require("uglify-js"),
+    espree     = require("espree"),
+    escodegen  = require("escodegen"),
+    estraverse = require("estraverse");
+
+var Type      = protobuf.Type,
+    Service   = protobuf.Service,
+    Enum      = protobuf.Enum,
+    Namespace = protobuf.Namespace,
+    util      = protobuf.util;
+
+var out = [];
+var indent = 0;
+var config = {};
+
+static_target.description = "Static code without reflection (non-functional on its own)";
+
+function static_target(root, options, callback) {
+    config = options;
+    try {
+        var aliases = [];
+        if (config.decode)
+            aliases.push("Reader");
+        if (config.encode)
+            aliases.push("Writer");
+        aliases.push("util");
+        if (aliases.length) {
+            if (config.comments)
+                push("// Common aliases");
+            push((config.es6 ? "const " : "var ") + aliases.map(function(name) { return "$" + name + " = $protobuf." + name; }).join(", ") + ";");
+            push("");
+        }
+        if (config.comments) {
+            if (root.comment) {
+                pushComment("@fileoverview " + root.comment);
+                push("");
+            }
+            push("// Exported root namespace");
+        }
+        var rootProp = util.safeProp(config.root || "default");
+        push((config.es6 ? "const" : "var") + " $root = $protobuf.roots" + rootProp + " || ($protobuf.roots" + rootProp + " = {});");
+        buildNamespace(null, root);
+        return callback(null, out.join("\n"));
+    } catch (err) {
+        return callback(err);
+    } finally {
+        out = [];
+        indent = 0;
+        config = {};
+    }
+}
+
+function push(line) {
+    if (line === "")
+        return out.push("");
+    var ind = "";
+    for (var i = 0; i < indent; ++i)
+        ind += "    ";
+    return out.push(ind + line);
+}
+
+function pushComment(lines) {
+    if (!config.comments)
+        return;
+    var split = [];
+    for (var i = 0; i < lines.length; ++i)
+        if (lines[i] != null && lines[i].substring(0, 8) !== "@exclude")
+            Array.prototype.push.apply(split, lines[i].split(/\r?\n/g));
+    push("/**");
+    split.forEach(function(line) {
+        if (line === null)
+            return;
+        push(" * " + line.replace(/\*\//g, "* /"));
+    });
+    push(" */");
+}
+
+function exportName(object, asInterface) {
+    if (asInterface) {
+        if (object.__interfaceName)
+            return object.__interfaceName;
+    } else if (object.__exportName)
+        return object.__exportName;
+    var parts = object.fullName.substring(1).split("."),
+        i = 0;
+    while (i < parts.length)
+        parts[i] = escapeName(parts[i++]);
+    if (asInterface)
+        parts[i - 1] = "I" + parts[i - 1];
+    return object[asInterface ? "__interfaceName" : "__exportName"] = parts.join(".");
+}
+
+function escapeName(name) {
+    if (!name)
+        return "$root";
+    return util.isReserved(name) ? name + "_" : name;
+}
+
+function aOrAn(name) {
+    return ((/^[hH](?:ou|on|ei)/.test(name) || /^[aeiouAEIOU][a-z]/.test(name)) && !/^us/i.test(name)
+        ? "an "
+        : "a ") + name;
+}
+
+function buildNamespace(ref, ns) {
+    if (!ns)
+        return;
+    if (ns.name !== "") {
+        push("");
+        if (!ref && config.es6)
+            push("export const " + escapeName(ns.name) + " = " + escapeName(ref) + "." + escapeName(ns.name) + " = (() => {");
+        else
+            push(escapeName(ref) + "." + escapeName(ns.name) + " = (function() {");
+        ++indent;
+    }
+
+    if (ns instanceof Type) {
+        buildType(undefined, ns);
+    } else if (ns instanceof Service)
+        buildService(undefined, ns);
+    else if (ns.name !== "") {
+        push("");
+        pushComment([
+            ns.comment || "Namespace " + ns.name + ".",
+            ns.parent instanceof protobuf.Root ? "@exports " + escapeName(ns.name) : "@memberof " + exportName(ns.parent),
+            "@namespace"
+        ]);
+        push((config.es6 ? "const" : "var") + " " + escapeName(ns.name) + " = {};");
+    }
+
+    ns.nestedArray.forEach(function(nested) {
+        if (nested instanceof Enum)
+            buildEnum(ns.name, nested);
+        else if (nested instanceof Namespace)
+            buildNamespace(ns.name, nested);
+    });
+    if (ns.name !== "") {
+        push("");
+        push("return " + escapeName(ns.name) + ";");
+        --indent;
+        push("})();");
+    }
+}
+
+var reduceableBlockStatements = {
+    IfStatement: true,
+    ForStatement: true,
+    WhileStatement: true
+};
+
+var shortVars = {
+    "r": "reader",
+    "w": "writer",
+    "m": "message",
+    "t": "tag",
+    "l": "length",
+    "c": "end", "c2": "end2",
+    "k": "key",
+    "ks": "keys", "ks2": "keys2",
+    "e": "error",
+    "f": "impl",
+    "o": "options",
+    "d": "object",
+    "n": "long",
+    "p": "properties"
+};
+
+function beautifyCode(code) {
+    // Add semicolons
+    code = UglifyJS.minify(code, {
+        compress: false,
+        mangle: false,
+        output: { beautify: true }
+    }).code;
+    // Properly beautify
+    var ast = espree.parse(code);
+    estraverse.replace(ast, {
+        enter: function(node, parent) {
+            // rename short vars
+            if (node.type === "Identifier" && (parent.property !== node || parent.computed) && shortVars[node.name])
+                return {
+                    "type": "Identifier",
+                    "name": shortVars[node.name]
+                };
+            // replace var with let if es6
+            if (config.es6 && node.type === "VariableDeclaration" && node.kind === "var") {
+                node.kind = "let";
+                return undefined;
+            }
+            // remove braces around block statements with a single child
+            if (node.type === "BlockStatement" && reduceableBlockStatements[parent.type] && node.body.length === 1)
+                return node.body[0];
+            return undefined;
+        }
+    });
+    code = escodegen.generate(ast, {
+        format: {
+            newline: "\n",
+            quotes: "double"
+        }
+    });
+    // Add id, wireType comments
+    if (config.comments)
+        code = code.replace(/\.uint32\((\d+)\)/g, function($0, $1) {
+            var id = $1 >>> 3,
+                wireType = $1 & 7;
+            return ".uint32(/* id " + id + ", wireType " + wireType + " =*/" + $1 + ")";
+        });
+    return code;
+}
+
+var renameVars = {
+    "Writer": "$Writer",
+    "Reader": "$Reader",
+    "util": "$util"
+};
+
+function buildFunction(type, functionName, gen, scope) {
+    var code = gen.toString(functionName)
+        .replace(/((?!\.)types\[\d+])(\.values)/g, "$1"); // enums: use types[N] instead of reflected types[N].values
+
+    var ast = espree.parse(code);
+    /* eslint-disable no-extra-parens */
+    estraverse.replace(ast, {
+        enter: function(node, parent) {
+            // rename vars
+            if (
+                node.type === "Identifier" && renameVars[node.name]
+                && (
+                    (parent.type === "MemberExpression" && parent.object === node)
+                 || (parent.type === "BinaryExpression" && parent.right === node)
+                )
+            )
+                return {
+                    "type": "Identifier",
+                    "name": renameVars[node.name]
+                };
+            // replace this.ctor with the actual ctor
+            if (
+                node.type === "MemberExpression"
+             && node.object.type === "ThisExpression"
+             && node.property.type === "Identifier" && node.property.name === "ctor"
+            )
+                return {
+                    "type": "Identifier",
+                    "name": "$root" + type.fullName
+                };
+            // replace types[N] with the field's actual type
+            if (
+                node.type === "MemberExpression"
+             && node.object.type === "Identifier" && node.object.name === "types"
+             && node.property.type === "Literal"
+            )
+                return {
+                    "type": "Identifier",
+                    "name": "$root" + type.fieldsArray[node.property.value].resolvedType.fullName
+                };
+            return undefined;
+        }
+    });
+    /* eslint-enable no-extra-parens */
+    code = escodegen.generate(ast, {
+        format: {
+            newline: "\n",
+            quotes: "double"
+        }
+    });
+
+    if (config.beautify)
+        code = beautifyCode(code);
+
+    code = code.replace(/ {4}/g, "\t");
+
+    var hasScope = scope && Object.keys(scope).length,
+        isCtor = functionName === type.name;
+
+    if (hasScope) // remove unused scope vars
+        Object.keys(scope).forEach(function(key) {
+            if (!new RegExp("\\b(" + key + ")\\b", "g").test(code))
+                delete scope[key];
+        });
+
+    var lines = code.split(/\n/g);
+    if (isCtor) // constructor
+        push(lines[0]);
+    else if (hasScope) // enclose in an iife
+        push(escapeName(type.name) + "." + escapeName(functionName) + " = (function(" + Object.keys(scope).map(escapeName).join(", ") + ") { return " + lines[0]);
+    else
+        push(escapeName(type.name) + "." + escapeName(functionName) + " = " + lines[0]);
+    lines.slice(1, lines.length - 1).forEach(function(line) {
+        var prev = indent;
+        var i = 0;
+        while (line.charAt(i++) === "\t")
+            ++indent;
+        push(line.trim());
+        indent = prev;
+    });
+    if (isCtor)
+        push("}");
+    else if (hasScope)
+        push("};})(" + Object.keys(scope).map(function(key) { return scope[key]; }).join(", ") + ");");
+    else
+        push("};");
+}
+
+function toJsType(field, forInterface) {
+    var type;
+
+    switch (field.type) {
+        case "double":
+        case "float":
+        case "int32":
+        case "uint32":
+        case "sint32":
+        case "fixed32":
+        case "sfixed32":
+            type = "number";
+            break;
+        case "int64":
+        case "uint64":
+        case "sint64":
+        case "fixed64":
+        case "sfixed64":
+            type = config.forceLong ? "Long" : config.forceNumber ? "number" : "number|Long";
+            break;
+        case "bool":
+            type = "boolean";
+            break;
+        case "string":
+            type = "string";
+            break;
+        case "bytes":
+            type = "Uint8Array";
+            break;
+        default:
+            if (field.resolve().resolvedType)
+                type = exportName(field.resolvedType, !(field.resolvedType instanceof protobuf.Enum || config.forceMessage));
+            else
+                type = "*"; // should not happen
+            break;
+    }
+    if (field.map)
+        return "Object.<string," + type + ">";
+    if (field.repeated) {
+        var fullType = field.preEncoded() ? type + "|Uint8Array" : type;
+        if (forInterface && field.useToArray()) {
+            return "$protobuf.ToArray.<" + fullType + ">|Array.<" + fullType + ">";
+        }
+        return "Array.<" + fullType + ">";
+    }
+    return type;
+}
+
+function buildType(ref, type) {
+
+    if (config.comments) {
+        var typeDef = [
+            "Properties of " + aOrAn(type.name) + ".",
+            type.parent instanceof protobuf.Root ? "@exports " + escapeName("I" + type.name) : "@memberof " + exportName(type.parent),
+            "@interface " + escapeName("I" + type.name)
+        ];
+        type.fieldsArray.forEach(function(field) {
+            var prop = util.safeProp(field.name); // either .name or ["name"]
+            prop = prop.substring(1, prop.charAt(0) === "[" ? prop.length - 1 : prop.length);
+            var jsType = toJsType(field, true);
+            if (field.optional)
+                jsType = jsType + "|null";
+            typeDef.push("@property {" + jsType + "} " + (field.optional ? "[" + prop + "]" : prop) + " " + (field.comment || type.name + " " + field.name));
+        });
+        push("");
+        pushComment(typeDef);
+    }
+
+    // constructor
+    push("");
+    pushComment([
+        "Constructs a new " + type.name + ".",
+        type.parent instanceof protobuf.Root ? "@exports " + escapeName(type.name) : "@memberof " + exportName(type.parent),
+        "@classdesc " + (type.comment || "Represents " + aOrAn(type.name) + "."),
+        config.comments ? "@implements " + escapeName("I" + type.name) : null,
+        "@constructor",
+        "@param {" + exportName(type, true) + "=} [" + (config.beautify ? "properties" : "p") + "] Properties to set"
+    ]);
+    buildFunction(type, type.name, Type.generateConstructor(type));
+
+    // default values
+    var firstField = true;
+    type.fieldsArray.forEach(function(field) {
+        field.resolve();
+        var prop = util.safeProp(field.name);
+        if (config.comments) {
+            push("");
+            var jsType = toJsType(field, false);
+            if (field.optional && !field.map && !field.repeated && field.resolvedType instanceof Type)
+                jsType = jsType + "|null|undefined";
+            pushComment([
+                field.comment || type.name + " " + field.name + ".",
+                "@member {" + jsType + "} " + field.name,
+                "@memberof " + exportName(type),
+                "@instance"
+            ]);
+        } else if (firstField) {
+            push("");
+            firstField = false;
+        }
+        if (field.repeated)
+            push(escapeName(type.name) + ".prototype" + prop + " = $util.emptyArray;"); // overwritten in constructor
+        else if (field.map)
+            push(escapeName(type.name) + ".prototype" + prop + " = $util.emptyObject;"); // overwritten in constructor
+        else if (field.long)
+            push(escapeName(type.name) + ".prototype" + prop + " = $util.Long ? $util.Long.fromBits("
+                    + JSON.stringify(field.typeDefault.low) + ","
+                    + JSON.stringify(field.typeDefault.high) + ","
+                    + JSON.stringify(field.typeDefault.unsigned)
+                + ") : " + field.typeDefault.toNumber(field.type.charAt(0) === "u") + ";");
+        else if (field.bytes) {
+            push(escapeName(type.name) + ".prototype" + prop + " = $util.newBuffer(" + JSON.stringify(Array.prototype.slice.call(field.typeDefault)) + ");");
+        } else
+            push(escapeName(type.name) + ".prototype" + prop + " = " + JSON.stringify(field.typeDefault) + ";");
+    });
+
+    // virtual oneof fields
+    var firstOneOf = true;
+    type.oneofsArray.forEach(function(oneof) {
+        if (firstOneOf) {
+            firstOneOf = false;
+            push("");
+            if (config.comments)
+                push("// OneOf field names bound to virtual getters and setters");
+            push((config.es6 ? "let" : "var") + " $oneOfFields;");
+        }
+        oneof.resolve();
+        push("");
+        pushComment([
+            oneof.comment || type.name + " " + oneof.name + ".",
+            "@member {" + oneof.oneof.map(JSON.stringify).join("|") + "|undefined} " + escapeName(oneof.name),
+            "@memberof " + exportName(type),
+            "@instance"
+        ]);
+        push("Object.defineProperty(" + escapeName(type.name) + ".prototype, " + JSON.stringify(oneof.name) +", {");
+        ++indent;
+            push("get: $util.oneOfGetter($oneOfFields = [" + oneof.oneof.map(JSON.stringify).join(", ") + "]),");
+            push("set: $util.oneOfSetter($oneOfFields)");
+        --indent;
+        push("});");
+    });
+
+    if (config.create) {
+        push("");
+        pushComment([
+            "Creates a new " + type.name + " instance using the specified properties.",
+            "@function create",
+            "@memberof " + exportName(type),
+            "@static",
+            "@param {" + exportName(type, true) + "=} [properties] Properties to set",
+            "@returns {" + exportName(type) + "} " + type.name + " instance"
+        ]);
+        push(escapeName(type.name) + ".create = function create(properties) {");
+            ++indent;
+            push("return new " + escapeName(type.name) + "(properties);");
+            --indent;
+        push("};");
+    }
+
+    if (config.encode) {
+        push("");
+        pushComment([
+            "Encodes the specified " + type.name + " message. Does not implicitly {@link " + exportName(type) + ".verify|verify} messages.",
+            "@function encode",
+            "@memberof " + exportName(type),
+            "@static",
+            "@param {" + exportName(type, !config.forceMessage) + "} " + (config.beautify ? "message" : "m") + " " + type.name + " message or plain object to encode",
+            "@param {$protobuf.Writer} [" + (config.beautify ? "writer" : "w") + "] Writer to encode to",
+            "@returns {$protobuf.Writer} Writer"
+        ]);
+        buildFunction(type, "encode", protobuf.encoder(type));
+
+        if (config.delimited) {
+            push("");
+            pushComment([
+                "Encodes the specified " + type.name + " message, length delimited. Does not implicitly {@link " + exportName(type) + ".verify|verify} messages.",
+                "@function encodeDelimited",
+                "@memberof " + exportName(type),
+                "@static",
+                "@param {" + exportName(type, !config.forceMessage) + "} message " + type.name + " message or plain object to encode",
+                "@param {$protobuf.Writer} [writer] Writer to encode to",
+                "@returns {$protobuf.Writer} Writer"
+            ]);
+            push(escapeName(type.name) + ".encodeDelimited = function encodeDelimited(message, writer) {");
+            ++indent;
+            push("return this.encode(message, writer).ldelim();");
+            --indent;
+            push("};");
+        }
+    }
+
+    if (config.decode) {
+        push("");
+        pushComment([
+            "Decodes " + aOrAn(type.name) + " message from the specified reader or buffer.",
+            "@function decode",
+            "@memberof " + exportName(type),
+            "@static",
+            "@param {$protobuf.Reader|Uint8Array} " + (config.beautify ? "reader" : "r") + " Reader or buffer to decode from",
+            "@param {number} [" + (config.beautify ? "length" : "l") + "] Message length if known beforehand",
+            "@returns {" + exportName(type) + "} " + type.name,
+            "@throws {Error} If the payload is not a reader or valid buffer",
+            "@throws {$protobuf.util.ProtocolError} If required fields are missing"
+        ]);
+        buildFunction(type, "decode", protobuf.decoder(type));
+
+        if (config.delimited) {
+            push("");
+            pushComment([
+                "Decodes " + aOrAn(type.name) + " message from the specified reader or buffer, length delimited.",
+                "@function decodeDelimited",
+                "@memberof " + exportName(type),
+                "@static",
+                "@param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from",
+                "@returns {" + exportName(type) + "} " + type.name,
+                "@throws {Error} If the payload is not a reader or valid buffer",
+                "@throws {$protobuf.util.ProtocolError} If required fields are missing"
+            ]);
+            push(escapeName(type.name) + ".decodeDelimited = function decodeDelimited(reader) {");
+            ++indent;
+                push("if (!(reader instanceof $Reader))");
+                ++indent;
+                    push("reader = new $Reader(reader);");
+                --indent;
+                push("return this.decode(reader, reader.uint32());");
+            --indent;
+            push("};");
+        }
+    }
+
+    if (config.verify) {
+        push("");
+        pushComment([
+            "Verifies " + aOrAn(type.name) + " message.",
+            "@function verify",
+            "@memberof " + exportName(type),
+            "@static",
+            "@param {Object.<string,*>} " + (config.beautify ? "message" : "m") + " Plain object to verify",
+            "@returns {string|null} `null` if valid, otherwise the reason why it is not"
+        ]);
+        buildFunction(type, "verify", protobuf.verifier(type));
+    }
+
+    if (config.convert) {
+        if (config.fromObject) {
+            push("");
+            pushComment([
+                "Creates " + aOrAn(type.name) + " message from a plain object. Also converts values to their respective internal types.",
+                "@function fromObject",
+                "@memberof " + exportName(type),
+                "@static",
+                "@param {Object.<string,*>} " + (config.beautify ? "object" : "d") + " Plain object",
+                "@returns {" + exportName(type) + "} " + type.name
+            ]);
+            buildFunction(type, "fromObject", protobuf.converter.fromObject(type));
+        }
+
+        push("");
+        pushComment([
+            "Creates a plain object from " + aOrAn(type.name) + " message. Also converts values to other types if specified.",
+            "@function toObject",
+            "@memberof " + exportName(type),
+            "@static",
+            "@param {" + exportName(type) + "} " + (config.beautify ? "message" : "m") + " " + type.name,
+            "@param {$protobuf.IConversionOptions} [" + (config.beautify ? "options" : "o") + "] Conversion options",
+            "@returns {Object.<string,*>} Plain object"
+        ]);
+        buildFunction(type, "toObject", protobuf.converter.toObject(type));
+
+        push("");
+        pushComment([
+            "Converts this " + type.name + " to JSON.",
+            "@function toJSON",
+            "@memberof " + exportName(type),
+            "@instance",
+            "@returns {Object.<string,*>} JSON object"
+        ]);
+        push(escapeName(type.name) + ".prototype.toJSON = function toJSON() {");
+        ++indent;
+            push("return this.constructor.toObject(this, $protobuf.util.toJSONOptions);");
+        --indent;
+        push("};");
+    }
+}
+
+function buildService(ref, service) {
+
+    push("");
+    pushComment([
+        "Constructs a new " + service.name + " service.",
+        service.parent instanceof protobuf.Root ? "@exports " + escapeName(service.name) : "@memberof " + exportName(service.parent),
+        "@classdesc " + (service.comment || "Represents " + aOrAn(service.name)),
+        "@extends $protobuf.rpc.Service",
+        "@constructor",
+        "@param {$protobuf.RPCImpl} rpcImpl RPC implementation",
+        "@param {boolean} [requestDelimited=false] Whether requests are length-delimited",
+        "@param {boolean} [responseDelimited=false] Whether responses are length-delimited"
+    ]);
+    push("function " + escapeName(service.name) + "(rpcImpl, requestDelimited, responseDelimited) {");
+    ++indent;
+    push("$protobuf.rpc.Service.call(this, rpcImpl, requestDelimited, responseDelimited);");
+    --indent;
+    push("}");
+    push("");
+    push("(" + escapeName(service.name) + ".prototype = Object.create($protobuf.rpc.Service.prototype)).constructor = " + escapeName(service.name) + ";");
+
+    if (config.create) {
+        push("");
+        pushComment([
+            "Creates new " + service.name + " service using the specified rpc implementation.",
+            "@function create",
+            "@memberof " + exportName(service),
+            "@static",
+            "@param {$protobuf.RPCImpl} rpcImpl RPC implementation",
+            "@param {boolean} [requestDelimited=false] Whether requests are length-delimited",
+            "@param {boolean} [responseDelimited=false] Whether responses are length-delimited",
+            "@returns {" + escapeName(service.name) + "} RPC service. Useful where requests and/or responses are streamed."
+        ]);
+        push(escapeName(service.name) + ".create = function create(rpcImpl, requestDelimited, responseDelimited) {");
+            ++indent;
+            push("return new this(rpcImpl, requestDelimited, responseDelimited);");
+            --indent;
+        push("};");
+    }
+
+    service.methodsArray.forEach(function(method) {
+        method.resolve();
+        var lcName = protobuf.util.lcFirst(method.name),
+            cbName = escapeName(method.name + "Callback");
+        push("");
+        pushComment([
+            "Callback as used by {@link " + exportName(service) + "#" + escapeName(lcName) + "}.",
+            // This is a more specialized version of protobuf.rpc.ServiceCallback
+            "@memberof " + exportName(service),
+            "@typedef " + cbName,
+            "@type {function}",
+            "@param {Error|null} error Error, if any",
+            "@param {" + exportName(method.resolvedResponseType) + "} [response] " + method.resolvedResponseType.name
+        ]);
+        push("");
+        pushComment([
+            method.comment || "Calls " + method.name + ".",
+            "@function " + lcName,
+            "@memberof " + exportName(service),
+            "@instance",
+            "@param {" + exportName(method.resolvedRequestType, !config.forceMessage) + "} request " + method.resolvedRequestType.name + " message or plain object",
+            "@param {" + exportName(service) + "." + cbName + "} callback Node-style callback called with the error, if any, and " + method.resolvedResponseType.name,
+            "@returns {undefined}",
+            "@variation 1"
+        ]);
+        push("Object.defineProperty(" + escapeName(service.name) + ".prototype" + util.safeProp(lcName) + " = function " + escapeName(lcName) + "(request, callback) {");
+            ++indent;
+            push("return this.rpcCall(" + escapeName(lcName) + ", $root." + exportName(method.resolvedRequestType) + ", $root." + exportName(method.resolvedResponseType) + ", request, callback);");
+            --indent;
+        push("}, \"name\", { value: " + JSON.stringify(method.name) + " });");
+        if (config.comments)
+            push("");
+        pushComment([
+            method.comment || "Calls " + method.name + ".",
+            "@function " + lcName,
+            "@memberof " + exportName(service),
+            "@instance",
+            "@param {" + exportName(method.resolvedRequestType, !config.forceMessage) + "} request " + method.resolvedRequestType.name + " message or plain object",
+            "@returns {Promise<" + exportName(method.resolvedResponseType) + ">} Promise",
+            "@variation 2"
+        ]);
+    });
+}
+
+function buildEnum(ref, enm) {
+
+    push("");
+    var comment = [
+        enm.comment || enm.name + " enum.",
+        enm.parent instanceof protobuf.Root ? "@exports " + escapeName(enm.name) : "@name " + exportName(enm),
+        config.forceEnumString ? "@enum {number}" : "@enum {string}",
+    ];
+    Object.keys(enm.values).forEach(function(key) {
+        var val = config.forceEnumString ? key : enm.values[key];
+        comment.push((config.forceEnumString ? "@property {string} " : "@property {number} ") + key + "=" + val + " " + (enm.comments[key] || key + " value"));
+    });
+    pushComment(comment);
+    push(escapeName(ref) + "." + escapeName(enm.name) + " = (function() {");
+    ++indent;
+        push((config.es6 ? "const" : "var") + " valuesById = {}, values = Object.create(valuesById);");
+        var aliased = [];
+        Object.keys(enm.values).forEach(function(key) {
+            var valueId = enm.values[key];
+            var val = config.forceEnumString ? JSON.stringify(key) : valueId;
+            if (aliased.indexOf(valueId) > -1)
+                push("values[" + JSON.stringify(key) + "] = " + val + ";");
+            else {
+                push("values[valuesById[" + valueId + "] = " + JSON.stringify(key) + "] = " + val + ";");
+                aliased.push(valueId);
+            }
+        });
+        push("return values;");
+    --indent;
+    push("})();");
+}

node_modules/@apollo/protobufjs/cli/util.js

@@ -0,0 +1,183 @@
+"use strict";
+var fs            = require("fs"),
+    path          = require("path"),
+    child_process = require("child_process");
+
+var semver;
+
+try {
+    // installed as a peer dependency
+    require.resolve("@apollo/protobufjs");
+    exports.pathToProtobufJs = "@apollo/protobufjs";
+} catch (e) {
+    // local development, i.e. forked from github
+    exports.pathToProtobufJs = "..";
+}
+
+var protobuf = require(exports.pathToProtobufJs);
+
+function basenameCompare(a, b) {
+    var aa = String(a).replace(/\.\w+$/, "").split(/(-?\d*\.?\d+)/g),
+        bb = String(b).replace(/\.\w+$/, "").split(/(-?\d*\.?\d+)/g);
+    for (var i = 0, k = Math.min(aa.length, bb.length); i < k; i++) {
+        var x = parseFloat(aa[i]) || aa[i].toLowerCase(),
+            y = parseFloat(bb[i]) || bb[i].toLowerCase();
+        if (x < y)
+            return -1;
+        if (x > y)
+            return 1;
+    }
+    return a.length < b.length ? -1 : 0;
+}
+
+exports.requireAll = function requireAll(dirname) {
+    dirname   = path.join(__dirname, dirname);
+    var files = fs.readdirSync(dirname).sort(basenameCompare),
+        all = {};
+    files.forEach(function(file) {
+        var basename = path.basename(file, ".js"),
+            extname  = path.extname(file);
+        if (extname === ".js")
+            all[basename] = require(path.join(dirname, file));
+    });
+    return all;
+};
+
+exports.traverse = function traverse(current, fn) {
+    fn(current);
+    if (current.fieldsArray)
+        current.fieldsArray.forEach(function(field) {
+            traverse(field, fn);
+        });
+    if (current.oneofsArray)
+        current.oneofsArray.forEach(function(oneof) {
+            traverse(oneof, fn);
+        });
+    if (current.methodsArray)
+        current.methodsArray.forEach(function(method) {
+            traverse(method, fn);
+        });
+    if (current.nestedArray)
+        current.nestedArray.forEach(function(nested) {
+            traverse(nested, fn);
+        });
+};
+
+exports.traverseResolved = function traverseResolved(current, fn) {
+    fn(current);
+    if (current.resolvedType)
+        traverseResolved(current.resolvedType, fn);
+    if (current.resolvedKeyType)
+        traverseResolved(current.resolvedKeyType, fn);
+    if (current.resolvedRequestType)
+        traverseResolved(current.resolvedRequestType, fn);
+    if (current.resolvedResponseType)
+        traverseResolved(current.resolvedResponseType, fn);
+};
+
+exports.inspect = function inspect(object, indent) {
+    if (!object)
+        return "";
+    var chalk = require("chalk");
+    var sb = [];
+    if (!indent)
+        indent = "";
+    var ind = indent ? indent.substring(0, indent.length - 2) + "└ " : "";
+    sb.push(
+        ind + chalk.bold(object.toString()) + (object.visible ? " (visible)" : ""),
+        indent + chalk.gray("parent: ") + object.parent
+    );
+    if (object instanceof protobuf.Field) {
+        if (object.extend !== undefined)
+            sb.push(indent + chalk.gray("extend: ") + object.extend);
+        if (object.partOf)
+            sb.push(indent + chalk.gray("oneof : ") + object.oneof);
+    }
+    sb.push("");
+    if (object.fieldsArray)
+        object.fieldsArray.forEach(function(field) {
+            sb.push(inspect(field, indent + "  "));
+        });
+    if (object.oneofsArray)
+        object.oneofsArray.forEach(function(oneof) {
+            sb.push(inspect(oneof, indent + "  "));
+        });
+    if (object.methodsArray)
+        object.methodsArray.forEach(function(service) {
+            sb.push(inspect(service, indent + "  "));
+        });
+    if (object.nestedArray)
+        object.nestedArray.forEach(function(nested) {
+            sb.push(inspect(nested, indent + "  "));
+        });
+    return sb.join("\n");
+};
+
+function modExists(name, version) {
+    for (var i = 0; i < module.paths.length; ++i) {
+        try {
+            var pkg = JSON.parse(fs.readFileSync(path.join(module.paths[i], name, "package.json")));
+            return semver
+                ? semver.satisfies(pkg.version, version)
+                : parseInt(pkg.version, 10) === parseInt(version.replace(/^[\^~]/, ""), 10); // used for semver only
+        } catch (e) {/**/}
+    }
+    return false;
+}
+
+function modInstall(install) {
+    child_process.execSync("npm --silent install " + (typeof install === "string" ? install : install.join(" ")), {
+        cwd: __dirname,
+        stdio: "ignore"
+    });
+}
+
+exports.setup = function() {
+    var pkg = require(path.join(__dirname, "..", "package.json"));
+    var version = pkg.dependencies["semver"] || pkg.devDependencies["semver"];
+    if (!modExists("semver", version)) {
+        process.stderr.write("installing semver@" + version + "\n");
+        modInstall("semver@" + version);
+    }
+    semver = require("semver"); // used from now on for version comparison
+    var install = [];
+    pkg.cliDependencies.forEach(function(name) {
+        if (name === "semver")
+            return;
+        version = pkg.dependencies[name] || pkg.devDependencies[name];
+        if (!modExists(name, version)) {
+            process.stderr.write("installing " + name + "@" + version + "\n");
+            install.push(name + "@" + version);
+        }
+    });
+    require("../scripts/postinstall"); // emit postinstall warning, if any
+    if (!install.length)
+        return;
+    modInstall(install);
+};
+
+exports.wrap = function(OUTPUT, options) {
+    var name = options.wrap || "default";
+    var wrap;
+    try {
+        // try built-in wrappers first
+        wrap = fs.readFileSync(path.join(__dirname, "wrappers", name + ".js")).toString("utf8");
+    } catch (e) {
+        // otherwise fetch the custom one
+        wrap = fs.readFileSync(path.resolve(process.cwd(), name)).toString("utf8");
+    }
+    wrap = wrap.replace(/\$DEPENDENCY/g, JSON.stringify(options.dependency || "@apollo/protobufjs"));
+    wrap = wrap.replace(/( *)\$OUTPUT;/, function($0, $1) {
+        return $1.length ? OUTPUT.replace(/^/mg, $1) : OUTPUT;
+    });
+    if (options.lint !== "")
+        wrap = "/*" + options.lint + "*/\n" + wrap;
+    return wrap.replace(/\r?\n/g, "\n");
+};
+
+exports.pad = function(str, len, l) {
+    while (str.length < len)
+        str = l ? str + " " : " " + str;
+    return str;
+};
+

node_modules/@apollo/protobufjs/cli/wrappers/amd.js

@@ -0,0 +1,7 @@
+define([$DEPENDENCY], function($protobuf) {
+    "use strict";
+
+    $OUTPUT;
+
+    return $root;
+});

node_modules/@apollo/protobufjs/cli/wrappers/closure.js

@@ -0,0 +1,7 @@
+(function($protobuf) {
+    "use strict";
+
+    $OUTPUT;
+
+    return $root;
+})(protobuf);

node_modules/@apollo/protobufjs/cli/wrappers/commonjs.js

@@ -0,0 +1,7 @@
+"use strict";
+
+var $protobuf = require($DEPENDENCY);
+
+$OUTPUT;
+
+module.exports = $root;

node_modules/@apollo/protobufjs/cli/wrappers/default.js

@@ -0,0 +1,15 @@
+(function(global, factory) { /* global define, require, module */
+
+    /* AMD */ if (typeof define === 'function' && define.amd)
+        define([$DEPENDENCY], factory);
+
+    /* CommonJS */ else if (typeof require === 'function' && typeof module === 'object' && module && module.exports)
+        module.exports = factory(require($DEPENDENCY));
+
+})(this, function($protobuf) {
+    "use strict";
+
+    $OUTPUT;
+
+    return $root;
+});

node_modules/@apollo/protobufjs/cli/wrappers/es6.js

@@ -0,0 +1,5 @@
+import $protobuf from $DEPENDENCY;
+
+$OUTPUT;
+
+export { $root as default };

node_modules/@apollo/protobufjs/dist/README.md

@@ -0,0 +1,31 @@
+This folder contains prebuilt browser versions of the full library. When sending pull requests, it is not required to update these.
+
+Prebuilt files are in source control to enable pain-free frontend respectively CDN usage:
+
+CDN usage
+---------
+
+Development:
+```
+<script src="//cdn.rawgit.com/dcodeIO/protobuf.js/6.X.X/dist/protobuf.js"></script>
+```
+
+Production:
+```
+<script src="//cdn.rawgit.com/dcodeIO/protobuf.js/6.X.X/dist/protobuf.min.js"></script>
+```
+
+**NOTE:** Remember to replace the version tag with the exact [release](https://github.com/dcodeIO/protobuf.js/tags) your project depends upon.
+
+Frontend usage
+--------------
+
+Development:
+```
+<script src="node_modules/protobufjs/dist/protobuf.js"></script>
+```
+
+Production:
+```
+<script src="node_modules/protobufjs/dist/protobuf.min.js"></script>
+```

node_modules/@apollo/protobufjs/dist/light/README.md

@@ -0,0 +1,31 @@
+This folder contains prebuilt browser versions of the light library suitable for use with reflection, static code and JSON descriptors / modules. When sending pull requests, it is not required to update these.
+
+Prebuilt files are in source control to enable pain-free frontend respectively CDN usage:
+
+CDN usage
+---------
+
+Development:
+```
+<script src="//cdn.rawgit.com/dcodeIO/protobuf.js/6.X.X/dist/light/protobuf.js"></script>
+```
+
+Production:
+```
+<script src="//cdn.rawgit.com/dcodeIO/protobuf.js/6.X.X/dist/light/protobuf.min.js"></script>
+```
+
+**NOTE:** Remember to replace the version tag with the exact [release](https://github.com/dcodeIO/protobuf.js/tags) your project depends upon.
+
+Frontend usage
+--------------
+
+Development:
+```
+<script src="node_modules/protobufjs/dist/light/protobuf.js"></script>
+```
+
+Production:
+```
+<script src="node_modules/protobufjs/dist/light/protobuf.min.js"></script>
+```

node_modules/@apollo/protobufjs/dist/minimal/README.md

@@ -0,0 +1,31 @@
+This folder contains prebuilt browser versions of the minimal library suitable for use with statically generated code only. When sending pull requests, it is not required to update these.
+
+Prebuilt files are in source control to enable pain-free frontend respectively CDN usage:
+
+CDN usage
+---------
+
+Development:
+```
+<script src="//cdn.rawgit.com/dcodeIO/protobuf.js/6.X.X/dist/minimal/protobuf.js"></script>
+```
+
+Production:
+```
+<script src="//cdn.rawgit.com/dcodeIO/protobuf.js/6.X.X/dist/minimal/protobuf.min.js"></script>
+```
+
+**NOTE:** Remember to replace the version tag with the exact [release](https://github.com/dcodeIO/protobuf.js/tags) your project depends upon.
+
+Frontend usage
+--------------
+
+Development:
+```
+<script src="node_modules/protobufjs/dist/minimal/protobuf.js"></script>
+```
+
+Production:
+```
+<script src="node_modules/protobufjs/dist/minimal/protobuf.min.js"></script>
+```

node_modules/@apollo/protobufjs/ext/debug/README.md

@@ -0,0 +1,4 @@
+protobufjs/ext/debug
+=========================
+
+Experimental debugging extension.

node_modules/@apollo/protobufjs/ext/debug/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var protobuf = require("../..");
+
+/**
+ * Debugging utility functions. Only present in debug builds.
+ * @namespace
+ */
+var debug = protobuf.debug = module.exports = {};
+
+var codegen = protobuf.util.codegen;
+
+var debugFnRe = /function ([^(]+)\(([^)]*)\) {/g;
+
+// Counts number of calls to any generated function
+function codegen_debug() {
+    codegen_debug.supported = codegen.supported;
+    codegen_debug.verbose = codegen.verbose;
+    var gen = codegen.apply(null, Array.prototype.slice.call(arguments));
+    gen.str = (function(str) { return function str_debug() {
+        return str.apply(null, Array.prototype.slice.call(arguments)).replace(debugFnRe, "function $1($2) {\n\t$1.calls=($1.calls|0)+1");
+    };})(gen.str);
+    return gen;
+}
+
+/**
+ * Returns a list of unused types within the specified root.
+ * @param {NamespaceBase} ns Namespace to search
+ * @returns {Type[]} Unused types
+ */
+debug.unusedTypes = function unusedTypes(ns) {
+
+    /* istanbul ignore if */
+    if (!(ns instanceof protobuf.Namespace))
+        throw TypeError("ns must be a Namespace");
+
+    /* istanbul ignore if */
+    if (!ns.nested)
+        return [];
+
+    var unused = [];
+    for (var names = Object.keys(ns.nested), i = 0; i < names.length; ++i) {
+        var nested = ns.nested[names[i]];
+        if (nested instanceof protobuf.Type) {
+            var calls = (nested.encode.calls|0)
+                      + (nested.decode.calls|0)
+                      + (nested.verify.calls|0)
+                      + (nested.toObject.calls|0)
+                      + (nested.fromObject.calls|0);
+            if (!calls)
+                unused.push(nested);
+        } else if (nested instanceof protobuf.Namespace)
+            Array.prototype.push.apply(unused, unusedTypes(nested));
+    }
+    return unused;
+};
+
+/**
+ * Enables debugging extensions.
+ * @returns {undefined}
+ */
+debug.enable = function enable() {
+    protobuf.util.codegen = codegen_debug;
+};
+
+/**
+ * Disables debugging extensions.
+ * @returns {undefined}
+ */
+debug.disable = function disable() {
+    protobuf.util.codegen = codegen;
+};

node_modules/@apollo/protobufjs/ext/descriptor/README.md

@@ -0,0 +1,72 @@
+protobufjs/ext/descriptor
+=========================
+
+Experimental extension for interoperability with [descriptor.proto](https://github.com/google/protobuf/blob/master/src/google/protobuf/descriptor.proto) types.
+
+Usage
+-----
+
+```js
+var protobuf   = require("@apollo/protobufjs"), // requires the full library
+    descriptor = require("@apollo/protobufjs/ext/descriptor");
+
+var root = ...;
+
+// convert any existing root instance to the corresponding descriptor type
+var descriptorMsg = root.toDescriptor("proto2");
+// ^ returns a FileDescriptorSet message, see table below
+
+// encode to a descriptor buffer
+var buffer = descriptor.FileDescriptorSet.encode(descriptorMsg).finish();
+
+// decode from a descriptor buffer
+var decodedDescriptor = descriptor.FileDescriptorSet.decode(buffer);
+
+// convert any existing descriptor to a root instance
+root = protobuf.Root.fromDescriptor(decodedDescriptor);
+// ^ expects a FileDescriptorSet message or buffer, see table below
+
+// and start all over again
+```
+
+API
+---
+
+The extension adds `.fromDescriptor(descriptor[, syntax])` and `#toDescriptor([syntax])` methods to reflection objects and exports the `.google.protobuf` namespace of the internally used `Root` instance containing the following types present in descriptor.proto:
+
+| Descriptor type               | protobuf.js type | Remarks
+|-------------------------------|------------------|---------
+| **FileDescriptorSet**         | Root             |
+| FileDescriptorProto           |                  | dependencies are not supported
+| FileOptions                   |                  |
+| FileOptionsOptimizeMode       |                  |
+| SourceCodeInfo                |                  | not supported
+| SourceCodeInfoLocation        |                  |
+| GeneratedCodeInfo             |                  | not supported
+| GeneratedCodeInfoAnnotation   |                  |
+| **DescriptorProto**           | Type             |
+| MessageOptions                |                  |
+| DescriptorProtoExtensionRange |                  |
+| DescriptorProtoReservedRange  |                  |
+| **FieldDescriptorProto**      | Field            |
+| FieldDescriptorProtoLabel     |                  |
+| FieldDescriptorProtoType      |                  |
+| FieldOptions                  |                  |
+| FieldOptionsCType             |                  |
+| FieldOptionsJSType            |                  |
+| **OneofDescriptorProto**      | OneOf            |
+| OneofOptions                  |                  |
+| **EnumDescriptorProto**       | Enum             |
+| EnumOptions                   |                  |
+| EnumValueDescriptorProto      |                  |
+| EnumValueOptions              |                  | not supported
+| **ServiceDescriptorProto**    | Service          |
+| ServiceOptions                |                  |
+| **MethodDescriptorProto**     | Method           |
+| MethodOptions                 |                  |
+| UninterpretedOption           |                  | not supported
+| UninterpretedOptionNamePart   |                  |
+
+Note that not all features of descriptor.proto translate perfectly to a protobuf.js root instance. A root instance has only limited knowlege of packages or individual files for example, which is then compensated by guessing and generating fictional file names.
+
+When using TypeScript, the respective interface types can be used to reference specific message instances (i.e. `protobuf.Message<IDescriptorProto>`).

node_modules/@apollo/protobufjs/ext/descriptor/index.d.ts

@@ -0,0 +1,191 @@
+import * as $protobuf from "../..";
+export const FileDescriptorSet: $protobuf.Type;
+
+export const FileDescriptorProto: $protobuf.Type;
+
+export const DescriptorProto: $protobuf.Type & {
+    ExtensionRange: $protobuf.Type,
+    ReservedRange: $protobuf.Type
+};
+
+export const FieldDescriptorProto: $protobuf.Type & {
+    Label: $protobuf.Enum,
+    Type: $protobuf.Enum
+};
+
+export const OneofDescriptorProto: $protobuf.Type;
+
+export const EnumDescriptorProto: $protobuf.Type;
+
+export const ServiceDescriptorProto: $protobuf.Type;
+
+export const EnumValueDescriptorProto: $protobuf.Type;
+
+export const MethodDescriptorProto: $protobuf.Type;
+
+export const FileOptions: $protobuf.Type & {
+    OptimizeMode: $protobuf.Enum
+};
+
+export const MessageOptions: $protobuf.Type;
+
+export const FieldOptions: $protobuf.Type & {
+    CType: $protobuf.Enum,
+    JSType: $protobuf.Enum
+};
+
+export const OneofOptions: $protobuf.Type;
+
+export const EnumOptions: $protobuf.Type;
+
+export const EnumValueOptions: $protobuf.Type;
+
+export const ServiceOptions: $protobuf.Type;
+
+export const MethodOptions: $protobuf.Type;
+
+export const UninterpretedOption: $protobuf.Type & {
+    NamePart: $protobuf.Type
+};
+
+export const SourceCodeInfo: $protobuf.Type & {
+    Location: $protobuf.Type
+};
+
+export const GeneratedCodeInfo: $protobuf.Type & {
+    Annotation: $protobuf.Type
+};
+
+export interface IFileDescriptorSet {
+    file: IFileDescriptorProto[];
+}
+
+export interface IFileDescriptorProto {
+    name?: string;
+    package?: string;
+    dependency?: any;
+    publicDependency?: any;
+    weakDependency?: any;
+    messageType?: IDescriptorProto[];
+    enumType?: IEnumDescriptorProto[];
+    service?: IServiceDescriptorProto[];
+    extension?: IFieldDescriptorProto[];
+    options?: IFileOptions;
+    sourceCodeInfo?: any;
+    syntax?: string;
+}
+
+export interface IFileOptions {
+    javaPackage?: string;
+    javaOuterClassname?: string;
+    javaMultipleFiles?: boolean;
+    javaGenerateEqualsAndHash?: boolean;
+    javaStringCheckUtf8?: boolean;
+    optimizeFor?: IFileOptionsOptimizeMode;
+    goPackage?: string;
+    ccGenericServices?: boolean;
+    javaGenericServices?: boolean;
+    pyGenericServices?: boolean;
+    deprecated?: boolean;
+    ccEnableArenas?: boolean;
+    objcClassPrefix?: string;
+    csharpNamespace?: string;
+}
+
+type IFileOptionsOptimizeMode = number;
+
+export interface IDescriptorProto {
+    name?: string;
+    field?: IFieldDescriptorProto[];
+    extension?: IFieldDescriptorProto[];
+    nestedType?: IDescriptorProto[];
+    enumType?: IEnumDescriptorProto[];
+    extensionRange?: IDescriptorProtoExtensionRange[];
+    oneofDecl?: IOneofDescriptorProto[];
+    options?: IMessageOptions;
+    reservedRange?: IDescriptorProtoReservedRange[];
+    reservedName?: string[];
+}
+
+export interface IMessageOptions {
+    mapEntry?: boolean;
+}
+
+export interface IDescriptorProtoExtensionRange {
+    start?: number;
+    end?: number;
+}
+
+export interface IDescriptorProtoReservedRange {
+    start?: number;
+    end?: number;
+}
+
+export interface IFieldDescriptorProto {
+    name?: string;
+    number?: number;
+    label?: IFieldDescriptorProtoLabel;
+    type?: IFieldDescriptorProtoType;
+    typeName?: string;
+    extendee?: string;
+    defaultValue?: string;
+    oneofIndex?: number;
+    jsonName?: any;
+    options?: IFieldOptions;
+}
+
+type IFieldDescriptorProtoLabel = number;
+
+type IFieldDescriptorProtoType = number;
+
+export interface IFieldOptions {
+    packed?: boolean;
+    jstype?: IFieldOptionsJSType;
+}
+
+type IFieldOptionsJSType = number;
+
+export interface IEnumDescriptorProto {
+    name?: string;
+    value?: IEnumValueDescriptorProto[];
+    options?: IEnumOptions;
+}
+
+export interface IEnumValueDescriptorProto {
+    name?: string;
+    number?: number;
+    options?: any;
+}
+
+export interface IEnumOptions {
+    allowAlias?: boolean;
+    deprecated?: boolean;
+}
+
+export interface IOneofDescriptorProto {
+    name?: string;
+    options?: any;
+}
+
+export interface IServiceDescriptorProto {
+    name?: string;
+    method?: IMethodDescriptorProto[];
+    options?: IServiceOptions;
+}
+
+export interface IServiceOptions {
+    deprecated?: boolean;
+}
+
+export interface IMethodDescriptorProto {
+    name?: string;
+    inputType?: string;
+    outputType?: string;
+    options?: IMethodOptions;
+    clientStreaming?: boolean;
+    serverStreaming?: boolean;
+}
+
+export interface IMethodOptions {
+    deprecated?: boolean;
+}

node_modules/@apollo/protobufjs/ext/descriptor/test.js

@@ -0,0 +1,54 @@
+/*eslint-disable no-console*/
+"use strict";
+var protobuf   = require("../../"),
+    descriptor = require(".");
+
+/* var proto = {
+    nested: {
+        Message: {
+            fields: {
+                foo: {
+                    type: "string",
+                    id: 1
+                }
+            },
+            nested: {
+                SubMessage: {
+                    fields: {}
+                }
+            }
+        },
+        Enum: {
+            values: {
+                ONE: 1,
+                TWO: 2
+            }
+        }
+    }
+}; */
+
+// var root = protobuf.Root.fromJSON(proto).resolveAll();
+var root = protobuf.loadSync("tests/data/google/protobuf/descriptor.proto").resolveAll();
+
+// console.log("Original proto", JSON.stringify(root, null, 2));
+
+var msg  = root.toDescriptor();
+
+// console.log("\nDescriptor", JSON.stringify(msg.toObject(), null, 2));
+
+var buf  = descriptor.FileDescriptorSet.encode(msg).finish();
+var root2 = protobuf.Root.fromDescriptor(buf, "proto2").resolveAll();
+
+// console.log("\nDecoded proto", JSON.stringify(root2, null, 2));
+
+var diff = require("deep-diff").diff(root.toJSON(), root2.toJSON());
+if (diff) {
+    diff.forEach(function(diff) {
+        console.log(diff.kind + " @ " + diff.path.join("."));
+        console.log("lhs:", typeof diff.lhs, diff.lhs);
+        console.log("rhs:", typeof diff.rhs, diff.rhs);
+        console.log();
+    });
+    process.exitCode = 1;
+} else
+    console.log("no differences");

node_modules/@apollo/protobufjs/google/LICENSE

@@ -0,0 +1,27 @@
+Copyright 2014, Google Inc.  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 Google Inc. 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.

node_modules/@apollo/protobufjs/google/README.md

@@ -0,0 +1 @@
+This folder contains stripped and pre-parsed definitions of common Google types. These files are not used by protobuf.js directly but are here so you can use or include them where required.

node_modules/@apollo/protobufjs/google/api/annotations.json

@@ -0,0 +1,83 @@
+{
+  "nested": {
+    "google": {
+      "nested": {
+        "api": {
+          "nested": {
+            "http": {
+              "type": "HttpRule",
+              "id": 72295728,
+              "extend": "google.protobuf.MethodOptions"
+            },
+            "HttpRule": {
+              "oneofs": {
+                "pattern": {
+                  "oneof": [
+                    "get",
+                    "put",
+                    "post",
+                    "delete",
+                    "patch",
+                    "custom"
+                  ]
+                }
+              },
+              "fields": {
+                "get": {
+                  "type": "string",
+                  "id": 2
+                },
+                "put": {
+                  "type": "string",
+                  "id": 3
+                },
+                "post": {
+                  "type": "string",
+                  "id": 4
+                },
+                "delete": {
+                  "type": "string",
+                  "id": 5
+                },
+                "patch": {
+                  "type": "string",
+                  "id": 6
+                },
+                "custom": {
+                  "type": "CustomHttpPattern",
+                  "id": 8
+                },
+                "selector": {
+                  "type": "string",
+                  "id": 1
+                },
+                "body": {
+                  "type": "string",
+                  "id": 7
+                },
+                "additionalBindings": {
+                  "rule": "repeated",
+                  "type": "HttpRule",
+                  "id": 11
+                }
+              }
+            }
+          }
+        },
+        "protobuf": {
+          "nested": {
+            "MethodOptions": {
+              "fields": {},
+              "extensions": [
+                [
+                  1000,
+                  536870911
+                ]
+              ]
+            }
+          }
+        }
+      }
+    }
+  }
+}

node_modules/@apollo/protobufjs/google/api/annotations.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package google.api;
+
+import "google/api/http.proto";
+import "google/protobuf/descriptor.proto";
+
+extend google.protobuf.MethodOptions {
+
+    HttpRule http = 72295728;
+}

node_modules/@apollo/protobufjs/google/api/http.json

@@ -0,0 +1,86 @@
+{
+  "nested": {
+    "google": {
+      "nested": {
+        "api": {
+          "nested": {
+            "Http": {
+              "fields": {
+                "rules": {
+                  "rule": "repeated",
+                  "type": "HttpRule",
+                  "id": 1
+                }
+              }
+            },
+            "HttpRule": {
+              "oneofs": {
+                "pattern": {
+                  "oneof": [
+                    "get",
+                    "put",
+                    "post",
+                    "delete",
+                    "patch",
+                    "custom"
+                  ]
+                }
+              },
+              "fields": {
+                "get": {
+                  "type": "string",
+                  "id": 2
+                },
+                "put": {
+                  "type": "string",
+                  "id": 3
+                },
+                "post": {
+                  "type": "string",
+                  "id": 4
+                },
+                "delete": {
+                  "type": "string",
+                  "id": 5
+                },
+                "patch": {
+                  "type": "string",
+                  "id": 6
+                },
+                "custom": {
+                  "type": "CustomHttpPattern",
+                  "id": 8
+                },
+                "selector": {
+                  "type": "string",
+                  "id": 1
+                },
+                "body": {
+                  "type": "string",
+                  "id": 7
+                },
+                "additionalBindings": {
+                  "rule": "repeated",
+                  "type": "HttpRule",
+                  "id": 11
+                }
+              }
+            },
+            "CustomHttpPattern": {
+              "fields": {
+                "kind": {
+                  "type": "string",
+                  "id": 1
+                },
+                "path": {
+                  "type": "string",
+                  "id": 2
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

node_modules/@apollo/protobufjs/google/api/http.proto

@@ -0,0 +1,31 @@
+syntax = "proto3";
+
+package google.api;
+
+message Http {
+
+    repeated HttpRule rules = 1;
+}
+
+message HttpRule {
+
+    oneof pattern {
+
+        string get = 2;
+        string put = 3;
+        string post = 4;
+        string delete = 5;
+        string patch = 6;
+        CustomHttpPattern custom = 8;
+    }
+
+    string selector = 1;
+    string body = 7;
+    repeated HttpRule additional_bindings = 11;
+}
+
+message CustomHttpPattern {
+
+    string kind = 1;
+    string path = 2;
+}

node_modules/@apollo/protobufjs/google/protobuf/api.json

@@ -0,0 +1,118 @@
+{
+  "nested": {
+    "google": {
+      "nested": {
+        "protobuf": {
+          "nested": {
+            "Api": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "methods": {
+                  "rule": "repeated",
+                  "type": "Method",
+                  "id": 2
+                },
+                "options": {
+                  "rule": "repeated",
+                  "type": "Option",
+                  "id": 3
+                },
+                "version": {
+                  "type": "string",
+                  "id": 4
+                },
+                "sourceContext": {
+                  "type": "SourceContext",
+                  "id": 5
+                },
+                "mixins": {
+                  "rule": "repeated",
+                  "type": "Mixin",
+                  "id": 6
+                },
+                "syntax": {
+                  "type": "Syntax",
+                  "id": 7
+                }
+              }
+            },
+            "Method": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "requestTypeUrl": {
+                  "type": "string",
+                  "id": 2
+                },
+                "requestStreaming": {
+                  "type": "bool",
+                  "id": 3
+                },
+                "responseTypeUrl": {
+                  "type": "string",
+                  "id": 4
+                },
+                "responseStreaming": {
+                  "type": "bool",
+                  "id": 5
+                },
+                "options": {
+                  "rule": "repeated",
+                  "type": "Option",
+                  "id": 6
+                },
+                "syntax": {
+                  "type": "Syntax",
+                  "id": 7
+                }
+              }
+            },
+            "Mixin": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "root": {
+                  "type": "string",
+                  "id": 2
+                }
+              }
+            },
+            "SourceContext": {
+              "fields": {
+                "fileName": {
+                  "type": "string",
+                  "id": 1
+                }
+              }
+            },
+            "Option": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "value": {
+                  "type": "Any",
+                  "id": 2
+                }
+              }
+            },
+            "Syntax": {
+              "values": {
+                "SYNTAX_PROTO2": 0,
+                "SYNTAX_PROTO3": 1
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

node_modules/@apollo/protobufjs/google/protobuf/api.proto

@@ -0,0 +1,34 @@
+syntax = "proto3";
+
+package google.protobuf;
+
+import "google/protobuf/source_context.proto";
+import "google/protobuf/type.proto";
+
+message Api {
+
+    string name = 1;
+    repeated Method methods = 2;
+    repeated Option options = 3;
+    string version = 4;
+    SourceContext source_context = 5;
+    repeated Mixin mixins = 6;
+    Syntax syntax = 7;
+}
+
+message Method {
+
+    string name = 1;
+    string request_type_url = 2;
+    bool request_streaming = 3;
+    string response_type_url = 4;
+    bool response_streaming = 5;
+    repeated Option options = 6;
+    Syntax syntax = 7;
+}
+
+message Mixin {
+
+    string name = 1;
+    string root = 2;
+}

node_modules/@apollo/protobufjs/google/protobuf/descriptor.json

@@ -0,0 +1,739 @@
+{
+  "nested": {
+    "google": {
+      "nested": {
+        "protobuf": {
+          "nested": {
+            "FileDescriptorSet": {
+              "fields": {
+                "file": {
+                  "rule": "repeated",
+                  "type": "FileDescriptorProto",
+                  "id": 1
+                }
+              }
+            },
+            "FileDescriptorProto": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "package": {
+                  "type": "string",
+                  "id": 2
+                },
+                "dependency": {
+                  "rule": "repeated",
+                  "type": "string",
+                  "id": 3
+                },
+                "publicDependency": {
+                  "rule": "repeated",
+                  "type": "int32",
+                  "id": 10,
+                  "options": {
+                    "packed": false
+                  }
+                },
+                "weakDependency": {
+                  "rule": "repeated",
+                  "type": "int32",
+                  "id": 11,
+                  "options": {
+                    "packed": false
+                  }
+                },
+                "messageType": {
+                  "rule": "repeated",
+                  "type": "DescriptorProto",
+                  "id": 4
+                },
+                "enumType": {
+                  "rule": "repeated",
+                  "type": "EnumDescriptorProto",
+                  "id": 5
+                },
+                "service": {
+                  "rule": "repeated",
+                  "type": "ServiceDescriptorProto",
+                  "id": 6
+                },
+                "extension": {
+                  "rule": "repeated",
+                  "type": "FieldDescriptorProto",
+                  "id": 7
+                },
+                "options": {
+                  "type": "FileOptions",
+                  "id": 8
+                },
+                "sourceCodeInfo": {
+                  "type": "SourceCodeInfo",
+                  "id": 9
+                },
+                "syntax": {
+                  "type": "string",
+                  "id": 12
+                }
+              }
+            },
+            "DescriptorProto": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "field": {
+                  "rule": "repeated",
+                  "type": "FieldDescriptorProto",
+                  "id": 2
+                },
+                "extension": {
+                  "rule": "repeated",
+                  "type": "FieldDescriptorProto",
+                  "id": 6
+                },
+                "nestedType": {
+                  "rule": "repeated",
+                  "type": "DescriptorProto",
+                  "id": 3
+                },
+                "enumType": {
+                  "rule": "repeated",
+                  "type": "EnumDescriptorProto",
+                  "id": 4
+                },
+                "extensionRange": {
+                  "rule": "repeated",
+                  "type": "ExtensionRange",
+                  "id": 5
+                },
+                "oneofDecl": {
+                  "rule": "repeated",
+                  "type": "OneofDescriptorProto",
+                  "id": 8
+                },
+                "options": {
+                  "type": "MessageOptions",
+                  "id": 7
+                },
+                "reservedRange": {
+                  "rule": "repeated",
+                  "type": "ReservedRange",
+                  "id": 9
+                },
+                "reservedName": {
+                  "rule": "repeated",
+                  "type": "string",
+                  "id": 10
+                }
+              },
+              "nested": {
+                "ExtensionRange": {
+                  "fields": {
+                    "start": {
+                      "type": "int32",
+                      "id": 1
+                    },
+                    "end": {
+                      "type": "int32",
+                      "id": 2
+                    }
+                  }
+                },
+                "ReservedRange": {
+                  "fields": {
+                    "start": {
+                      "type": "int32",
+                      "id": 1
+                    },
+                    "end": {
+                      "type": "int32",
+                      "id": 2
+                    }
+                  }
+                }
+              }
+            },
+            "FieldDescriptorProto": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "number": {
+                  "type": "int32",
+                  "id": 3
+                },
+                "label": {
+                  "type": "Label",
+                  "id": 4
+                },
+                "type": {
+                  "type": "Type",
+                  "id": 5
+                },
+                "typeName": {
+                  "type": "string",
+                  "id": 6
+                },
+                "extendee": {
+                  "type": "string",
+                  "id": 2
+                },
+                "defaultValue": {
+                  "type": "string",
+                  "id": 7
+                },
+                "oneofIndex": {
+                  "type": "int32",
+                  "id": 9
+                },
+                "jsonName": {
+                  "type": "string",
+                  "id": 10
+                },
+                "options": {
+                  "type": "FieldOptions",
+                  "id": 8
+                }
+              },
+              "nested": {
+                "Type": {
+                  "values": {
+                    "TYPE_DOUBLE": 1,
+                    "TYPE_FLOAT": 2,
+                    "TYPE_INT64": 3,
+                    "TYPE_UINT64": 4,
+                    "TYPE_INT32": 5,
+                    "TYPE_FIXED64": 6,
+                    "TYPE_FIXED32": 7,
+                    "TYPE_BOOL": 8,
+                    "TYPE_STRING": 9,
+                    "TYPE_GROUP": 10,
+                    "TYPE_MESSAGE": 11,
+                    "TYPE_BYTES": 12,
+                    "TYPE_UINT32": 13,
+                    "TYPE_ENUM": 14,
+                    "TYPE_SFIXED32": 15,
+                    "TYPE_SFIXED64": 16,
+                    "TYPE_SINT32": 17,
+                    "TYPE_SINT64": 18
+                  }
+                },
+                "Label": {
+                  "values": {
+                    "LABEL_OPTIONAL": 1,
+                    "LABEL_REQUIRED": 2,
+                    "LABEL_REPEATED": 3
+                  }
+                }
+              }
+            },
+            "OneofDescriptorProto": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "options": {
+                  "type": "OneofOptions",
+                  "id": 2
+                }
+              }
+            },
+            "EnumDescriptorProto": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "value": {
+                  "rule": "repeated",
+                  "type": "EnumValueDescriptorProto",
+                  "id": 2
+                },
+                "options": {
+                  "type": "EnumOptions",
+                  "id": 3
+                }
+              }
+            },
+            "EnumValueDescriptorProto": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "number": {
+                  "type": "int32",
+                  "id": 2
+                },
+                "options": {
+                  "type": "EnumValueOptions",
+                  "id": 3
+                }
+              }
+            },
+            "ServiceDescriptorProto": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "method": {
+                  "rule": "repeated",
+                  "type": "MethodDescriptorProto",
+                  "id": 2
+                },
+                "options": {
+                  "type": "ServiceOptions",
+                  "id": 3
+                }
+              }
+            },
+            "MethodDescriptorProto": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "inputType": {
+                  "type": "string",
+                  "id": 2
+                },
+                "outputType": {
+                  "type": "string",
+                  "id": 3
+                },
+                "options": {
+                  "type": "MethodOptions",
+                  "id": 4
+                },
+                "clientStreaming": {
+                  "type": "bool",
+                  "id": 5
+                },
+                "serverStreaming": {
+                  "type": "bool",
+                  "id": 6
+                }
+              }
+            },
+            "FileOptions": {
+              "fields": {
+                "javaPackage": {
+                  "type": "string",
+                  "id": 1
+                },
+                "javaOuterClassname": {
+                  "type": "string",
+                  "id": 8
+                },
+                "javaMultipleFiles": {
+                  "type": "bool",
+                  "id": 10
+                },
+                "javaGenerateEqualsAndHash": {
+                  "type": "bool",
+                  "id": 20,
+                  "options": {
+                    "deprecated": true
+                  }
+                },
+                "javaStringCheckUtf8": {
+                  "type": "bool",
+                  "id": 27
+                },
+                "optimizeFor": {
+                  "type": "OptimizeMode",
+                  "id": 9,
+                  "options": {
+                    "default": "SPEED"
+                  }
+                },
+                "goPackage": {
+                  "type": "string",
+                  "id": 11
+                },
+                "ccGenericServices": {
+                  "type": "bool",
+                  "id": 16
+                },
+                "javaGenericServices": {
+                  "type": "bool",
+                  "id": 17
+                },
+                "pyGenericServices": {
+                  "type": "bool",
+                  "id": 18
+                },
+                "deprecated": {
+                  "type": "bool",
+                  "id": 23
+                },
+                "ccEnableArenas": {
+                  "type": "bool",
+                  "id": 31
+                },
+                "objcClassPrefix": {
+                  "type": "string",
+                  "id": 36
+                },
+                "csharpNamespace": {
+                  "type": "string",
+                  "id": 37
+                },
+                "uninterpretedOption": {
+                  "rule": "repeated",
+                  "type": "UninterpretedOption",
+                  "id": 999
+                }
+              },
+              "extensions": [
+                [
+                  1000,
+                  536870911
+                ]
+              ],
+              "reserved": [
+                [
+                  38,
+                  38
+                ]
+              ],
+              "nested": {
+                "OptimizeMode": {
+                  "values": {
+                    "SPEED": 1,
+                    "CODE_SIZE": 2,
+                    "LITE_RUNTIME": 3
+                  }
+                }
+              }
+            },
+            "MessageOptions": {
+              "fields": {
+                "messageSetWireFormat": {
+                  "type": "bool",
+                  "id": 1
+                },
+                "noStandardDescriptorAccessor": {
+                  "type": "bool",
+                  "id": 2
+                },
+                "deprecated": {
+                  "type": "bool",
+                  "id": 3
+                },
+                "mapEntry": {
+                  "type": "bool",
+                  "id": 7
+                },
+                "uninterpretedOption": {
+                  "rule": "repeated",
+                  "type": "UninterpretedOption",
+                  "id": 999
+                }
+              },
+              "extensions": [
+                [
+                  1000,
+                  536870911
+                ]
+              ],
+              "reserved": [
+                [
+                  8,
+                  8
+                ]
+              ]
+            },
+            "FieldOptions": {
+              "fields": {
+                "ctype": {
+                  "type": "CType",
+                  "id": 1,
+                  "options": {
+                    "default": "STRING"
+                  }
+                },
+                "packed": {
+                  "type": "bool",
+                  "id": 2
+                },
+                "jstype": {
+                  "type": "JSType",
+                  "id": 6,
+                  "options": {
+                    "default": "JS_NORMAL"
+                  }
+                },
+                "lazy": {
+                  "type": "bool",
+                  "id": 5
+                },
+                "deprecated": {
+                  "type": "bool",
+                  "id": 3
+                },
+                "weak": {
+                  "type": "bool",
+                  "id": 10
+                },
+                "uninterpretedOption": {
+                  "rule": "repeated",
+                  "type": "UninterpretedOption",
+                  "id": 999
+                }
+              },
+              "extensions": [
+                [
+                  1000,
+                  536870911
+                ]
+              ],
+              "reserved": [
+                [
+                  4,
+                  4
+                ]
+              ],
+              "nested": {
+                "CType": {
+                  "values": {
+                    "STRING": 0,
+                    "CORD": 1,
+                    "STRING_PIECE": 2
+                  }
+                },
+                "JSType": {
+                  "values": {
+                    "JS_NORMAL": 0,
+                    "JS_STRING": 1,
+                    "JS_NUMBER": 2
+                  }
+                }
+              }
+            },
+            "OneofOptions": {
+              "fields": {
+                "uninterpretedOption": {
+                  "rule": "repeated",
+                  "type": "UninterpretedOption",
+                  "id": 999
+                }
+              },
+              "extensions": [
+                [
+                  1000,
+                  536870911
+                ]
+              ]
+            },
+            "EnumOptions": {
+              "fields": {
+                "allowAlias": {
+                  "type": "bool",
+                  "id": 2
+                },
+                "deprecated": {
+                  "type": "bool",
+                  "id": 3
+                },
+                "uninterpretedOption": {
+                  "rule": "repeated",
+                  "type": "UninterpretedOption",
+                  "id": 999
+                }
+              },
+              "extensions": [
+                [
+                  1000,
+                  536870911
+                ]
+              ]
+            },
+            "EnumValueOptions": {
+              "fields": {
+                "deprecated": {
+                  "type": "bool",
+                  "id": 1
+                },
+                "uninterpretedOption": {
+                  "rule": "repeated",
+                  "type": "UninterpretedOption",
+                  "id": 999
+                }
+              },
+              "extensions": [
+                [
+                  1000,
+                  536870911
+                ]
+              ]
+            },
+            "ServiceOptions": {
+              "fields": {
+                "deprecated": {
+                  "type": "bool",
+                  "id": 33
+                },
+                "uninterpretedOption": {
+                  "rule": "repeated",
+                  "type": "UninterpretedOption",
+                  "id": 999
+                }
+              },
+              "extensions": [
+                [
+                  1000,
+                  536870911
+                ]
+              ]
+            },
+            "MethodOptions": {
+              "fields": {
+                "deprecated": {
+                  "type": "bool",
+                  "id": 33
+                },
+                "uninterpretedOption": {
+                  "rule": "repeated",
+                  "type": "UninterpretedOption",
+                  "id": 999
+                }
+              },
+              "extensions": [
+                [
+                  1000,
+                  536870911
+                ]
+              ]
+            },
+            "UninterpretedOption": {
+              "fields": {
+                "name": {
+                  "rule": "repeated",
+                  "type": "NamePart",
+                  "id": 2
+                },
+                "identifierValue": {
+                  "type": "string",
+                  "id": 3
+                },
+                "positiveIntValue": {
+                  "type": "uint64",
+                  "id": 4
+                },
+                "negativeIntValue": {
+                  "type": "int64",
+                  "id": 5
+                },
+                "doubleValue": {
+                  "type": "double",
+                  "id": 6
+                },
+                "stringValue": {
+                  "type": "bytes",
+                  "id": 7
+                },
+                "aggregateValue": {
+                  "type": "string",
+                  "id": 8
+                }
+              },
+              "nested": {
+                "NamePart": {
+                  "fields": {
+                    "namePart": {
+                      "rule": "required",
+                      "type": "string",
+                      "id": 1
+                    },
+                    "isExtension": {
+                      "rule": "required",
+                      "type": "bool",
+                      "id": 2
+                    }
+                  }
+                }
+              }
+            },
+            "SourceCodeInfo": {
+              "fields": {
+                "location": {
+                  "rule": "repeated",
+                  "type": "Location",
+                  "id": 1
+                }
+              },
+              "nested": {
+                "Location": {
+                  "fields": {
+                    "path": {
+                      "rule": "repeated",
+                      "type": "int32",
+                      "id": 1
+                    },
+                    "span": {
+                      "rule": "repeated",
+                      "type": "int32",
+                      "id": 2
+                    },
+                    "leadingComments": {
+                      "type": "string",
+                      "id": 3
+                    },
+                    "trailingComments": {
+                      "type": "string",
+                      "id": 4
+                    },
+                    "leadingDetachedComments": {
+                      "rule": "repeated",
+                      "type": "string",
+                      "id": 6
+                    }
+                  }
+                }
+              }
+            },
+            "GeneratedCodeInfo": {
+              "fields": {
+                "annotation": {
+                  "rule": "repeated",
+                  "type": "Annotation",
+                  "id": 1
+                }
+              },
+              "nested": {
+                "Annotation": {
+                  "fields": {
+                    "path": {
+                      "rule": "repeated",
+                      "type": "int32",
+                      "id": 1
+                    },
+                    "sourceFile": {
+                      "type": "string",
+                      "id": 2
+                    },
+                    "begin": {
+                      "type": "int32",
+                      "id": 3
+                    },
+                    "end": {
+                      "type": "int32",
+                      "id": 4
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

node_modules/@apollo/protobufjs/google/protobuf/descriptor.proto

@@ -0,0 +1,286 @@
+syntax = "proto2";
+
+package google.protobuf;
+
+message FileDescriptorSet {
+
+    repeated FileDescriptorProto file = 1;
+}
+
+message FileDescriptorProto {
+
+    optional string name = 1;
+    optional string package = 2;
+    repeated string dependency = 3;
+    repeated int32 public_dependency = 10;
+    repeated int32 weak_dependency = 11;
+    repeated DescriptorProto message_type = 4;
+    repeated EnumDescriptorProto enum_type = 5;
+    repeated ServiceDescriptorProto service = 6;
+    repeated FieldDescriptorProto extension = 7;
+    optional FileOptions options = 8;
+    optional SourceCodeInfo source_code_info = 9;
+    optional string syntax = 12;
+}
+
+message DescriptorProto {
+
+    optional string name = 1;
+    repeated FieldDescriptorProto field = 2;
+    repeated FieldDescriptorProto extension = 6;
+    repeated DescriptorProto nested_type = 3;
+    repeated EnumDescriptorProto enum_type = 4;
+    repeated ExtensionRange extension_range = 5;
+    repeated OneofDescriptorProto oneof_decl = 8;
+    optional MessageOptions options = 7;
+    repeated ReservedRange reserved_range = 9;
+    repeated string reserved_name = 10;
+
+    message ExtensionRange {
+
+        optional int32 start = 1;
+        optional int32 end = 2;
+    }
+
+    message ReservedRange {
+
+        optional int32 start = 1;
+        optional int32 end = 2;
+    }
+}
+
+message FieldDescriptorProto {
+
+    optional string name = 1;
+    optional int32 number = 3;
+    optional Label label = 4;
+    optional Type type = 5;
+    optional string type_name = 6;
+    optional string extendee = 2;
+    optional string default_value = 7;
+    optional int32 oneof_index = 9;
+    optional string json_name = 10;
+    optional FieldOptions options = 8;
+
+    enum Type {
+
+        TYPE_DOUBLE = 1;
+        TYPE_FLOAT = 2;
+        TYPE_INT64 = 3;
+        TYPE_UINT64 = 4;
+        TYPE_INT32 = 5;
+        TYPE_FIXED64 = 6;
+        TYPE_FIXED32 = 7;
+        TYPE_BOOL = 8;
+        TYPE_STRING = 9;
+        TYPE_GROUP = 10;
+        TYPE_MESSAGE = 11;
+        TYPE_BYTES = 12;
+        TYPE_UINT32 = 13;
+        TYPE_ENUM = 14;
+        TYPE_SFIXED32 = 15;
+        TYPE_SFIXED64 = 16;
+        TYPE_SINT32 = 17;
+        TYPE_SINT64 = 18;
+    }
+
+    enum Label {
+
+        LABEL_OPTIONAL = 1;
+        LABEL_REQUIRED = 2;
+        LABEL_REPEATED = 3;
+    }
+}
+
+message OneofDescriptorProto {
+
+    optional string name = 1;
+    optional OneofOptions options = 2;
+}
+
+message EnumDescriptorProto {
+
+    optional string name = 1;
+    repeated EnumValueDescriptorProto value = 2;
+    optional EnumOptions options = 3;
+}
+
+message EnumValueDescriptorProto {
+
+    optional string name = 1;
+    optional int32 number = 2;
+    optional EnumValueOptions options = 3;
+}
+
+message ServiceDescriptorProto {
+
+    optional string name = 1;
+    repeated MethodDescriptorProto method = 2;
+    optional ServiceOptions options = 3;
+}
+
+message MethodDescriptorProto {
+
+    optional string name = 1;
+    optional string input_type = 2;
+    optional string output_type = 3;
+    optional MethodOptions options = 4;
+    optional bool client_streaming = 5;
+    optional bool server_streaming = 6;
+}
+
+message FileOptions {
+
+    optional string java_package = 1;
+    optional string java_outer_classname = 8;
+    optional bool java_multiple_files = 10;
+    optional bool java_generate_equals_and_hash = 20 [deprecated=true];
+    optional bool java_string_check_utf8 = 27;
+    optional OptimizeMode optimize_for = 9 [default=SPEED];
+    optional string go_package = 11;
+    optional bool cc_generic_services = 16;
+    optional bool java_generic_services = 17;
+    optional bool py_generic_services = 18;
+    optional bool deprecated = 23;
+    optional bool cc_enable_arenas = 31;
+    optional string objc_class_prefix = 36;
+    optional string csharp_namespace = 37;
+    repeated UninterpretedOption uninterpreted_option = 999;
+
+    enum OptimizeMode {
+
+        SPEED = 1;
+        CODE_SIZE = 2;
+        LITE_RUNTIME = 3;
+    }
+
+    extensions 1000 to max;
+
+    reserved 38;
+}
+
+message MessageOptions {
+
+    optional bool message_set_wire_format = 1;
+    optional bool no_standard_descriptor_accessor = 2;
+    optional bool deprecated = 3;
+    optional bool map_entry = 7;
+    repeated UninterpretedOption uninterpreted_option = 999;
+
+    extensions 1000 to max;
+
+    reserved 8;
+}
+
+message FieldOptions {
+
+    optional CType ctype = 1 [default=STRING];
+    optional bool packed = 2;
+    optional JSType jstype = 6 [default=JS_NORMAL];
+    optional bool lazy = 5;
+    optional bool deprecated = 3;
+    optional bool weak = 10;
+    repeated UninterpretedOption uninterpreted_option = 999;
+
+    enum CType {
+
+        STRING = 0;
+        CORD = 1;
+        STRING_PIECE = 2;
+    }
+
+    enum JSType {
+
+        JS_NORMAL = 0;
+        JS_STRING = 1;
+        JS_NUMBER = 2;
+    }
+
+    extensions 1000 to max;
+
+    reserved 4;
+}
+
+message OneofOptions {
+
+    repeated UninterpretedOption uninterpreted_option = 999;
+
+    extensions 1000 to max;
+}
+
+message EnumOptions {
+
+    optional bool allow_alias = 2;
+    optional bool deprecated = 3;
+    repeated UninterpretedOption uninterpreted_option = 999;
+
+    extensions 1000 to max;
+}
+
+message EnumValueOptions {
+
+    optional bool deprecated = 1;
+    repeated UninterpretedOption uninterpreted_option = 999;
+
+    extensions 1000 to max;
+}
+
+message ServiceOptions {
+
+    optional bool deprecated = 33;
+    repeated UninterpretedOption uninterpreted_option = 999;
+
+    extensions 1000 to max;
+}
+
+message MethodOptions {
+
+    optional bool deprecated = 33;
+    repeated UninterpretedOption uninterpreted_option = 999;
+
+    extensions 1000 to max;
+}
+
+message UninterpretedOption {
+
+    repeated NamePart name = 2;
+    optional string identifier_value = 3;
+    optional uint64 positive_int_value = 4;
+    optional int64 negative_int_value = 5;
+    optional double double_value = 6;
+    optional bytes string_value = 7;
+    optional string aggregate_value = 8;
+
+    message NamePart {
+
+        required string name_part = 1;
+        required bool is_extension = 2;
+    }
+}
+
+message SourceCodeInfo {
+
+    repeated Location location = 1;
+
+    message Location {
+
+        repeated int32 path = 1 [packed=true];
+        repeated int32 span = 2 [packed=true];
+        optional string leading_comments = 3;
+        optional string trailing_comments = 4;
+        repeated string leading_detached_comments = 6;
+    }
+}
+
+message GeneratedCodeInfo {
+
+    repeated Annotation annotation = 1;
+
+    message Annotation {
+
+        repeated int32 path = 1 [packed=true];
+        optional string source_file = 2;
+        optional int32 begin = 3;
+        optional int32 end = 4;
+    }
+}

node_modules/@apollo/protobufjs/google/protobuf/source_context.json

@@ -0,0 +1,20 @@
+{
+  "nested": {
+    "google": {
+      "nested": {
+        "protobuf": {
+          "nested": {
+            "SourceContext": {
+              "fields": {
+                "fileName": {
+                  "type": "string",
+                  "id": 1
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

node_modules/@apollo/protobufjs/google/protobuf/source_context.proto

@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+package google.protobuf;
+
+message SourceContext {
+    string file_name = 1;
+}

node_modules/@apollo/protobufjs/google/protobuf/type.json

@@ -0,0 +1,202 @@
+{
+  "nested": {
+    "google": {
+      "nested": {
+        "protobuf": {
+          "nested": {
+            "Type": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "fields": {
+                  "rule": "repeated",
+                  "type": "Field",
+                  "id": 2
+                },
+                "oneofs": {
+                  "rule": "repeated",
+                  "type": "string",
+                  "id": 3
+                },
+                "options": {
+                  "rule": "repeated",
+                  "type": "Option",
+                  "id": 4
+                },
+                "sourceContext": {
+                  "type": "SourceContext",
+                  "id": 5
+                },
+                "syntax": {
+                  "type": "Syntax",
+                  "id": 6
+                }
+              }
+            },
+            "Field": {
+              "fields": {
+                "kind": {
+                  "type": "Kind",
+                  "id": 1
+                },
+                "cardinality": {
+                  "type": "Cardinality",
+                  "id": 2
+                },
+                "number": {
+                  "type": "int32",
+                  "id": 3
+                },
+                "name": {
+                  "type": "string",
+                  "id": 4
+                },
+                "typeUrl": {
+                  "type": "string",
+                  "id": 6
+                },
+                "oneofIndex": {
+                  "type": "int32",
+                  "id": 7
+                },
+                "packed": {
+                  "type": "bool",
+                  "id": 8
+                },
+                "options": {
+                  "rule": "repeated",
+                  "type": "Option",
+                  "id": 9
+                },
+                "jsonName": {
+                  "type": "string",
+                  "id": 10
+                },
+                "defaultValue": {
+                  "type": "string",
+                  "id": 11
+                }
+              },
+              "nested": {
+                "Kind": {
+                  "values": {
+                    "TYPE_UNKNOWN": 0,
+                    "TYPE_DOUBLE": 1,
+                    "TYPE_FLOAT": 2,
+                    "TYPE_INT64": 3,
+                    "TYPE_UINT64": 4,
+                    "TYPE_INT32": 5,
+                    "TYPE_FIXED64": 6,
+                    "TYPE_FIXED32": 7,
+                    "TYPE_BOOL": 8,
+                    "TYPE_STRING": 9,
+                    "TYPE_GROUP": 10,
+                    "TYPE_MESSAGE": 11,
+                    "TYPE_BYTES": 12,
+                    "TYPE_UINT32": 13,
+                    "TYPE_ENUM": 14,
+                    "TYPE_SFIXED32": 15,
+                    "TYPE_SFIXED64": 16,
+                    "TYPE_SINT32": 17,
+                    "TYPE_SINT64": 18
+                  }
+                },
+                "Cardinality": {
+                  "values": {
+                    "CARDINALITY_UNKNOWN": 0,
+                    "CARDINALITY_OPTIONAL": 1,
+                    "CARDINALITY_REQUIRED": 2,
+                    "CARDINALITY_REPEATED": 3
+                  }
+                }
+              }
+            },
+            "Enum": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "enumvalue": {
+                  "rule": "repeated",
+                  "type": "EnumValue",
+                  "id": 2
+                },
+                "options": {
+                  "rule": "repeated",
+                  "type": "Option",
+                  "id": 3
+                },
+                "sourceContext": {
+                  "type": "SourceContext",
+                  "id": 4
+                },
+                "syntax": {
+                  "type": "Syntax",
+                  "id": 5
+                }
+              }
+            },
+            "EnumValue": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "number": {
+                  "type": "int32",
+                  "id": 2
+                },
+                "options": {
+                  "rule": "repeated",
+                  "type": "Option",
+                  "id": 3
+                }
+              }
+            },
+            "Option": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "value": {
+                  "type": "Any",
+                  "id": 2
+                }
+              }
+            },
+            "Syntax": {
+              "values": {
+                "SYNTAX_PROTO2": 0,
+                "SYNTAX_PROTO3": 1
+              }
+            },
+            "Any": {
+              "fields": {
+                "type_url": {
+                  "type": "string",
+                  "id": 1
+                },
+                "value": {
+                  "type": "bytes",
+                  "id": 2
+                }
+              }
+            },
+            "SourceContext": {
+              "fields": {
+                "fileName": {
+                  "type": "string",
+                  "id": 1
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

node_modules/@apollo/protobufjs/google/protobuf/type.proto

@@ -0,0 +1,89 @@
+syntax = "proto3";
+
+package google.protobuf;
+
+import "google/protobuf/any.proto";
+import "google/protobuf/source_context.proto";
+
+message Type {
+
+    string name = 1;
+    repeated Field fields = 2;
+    repeated string oneofs = 3;
+    repeated Option options = 4;
+    SourceContext source_context = 5;
+    Syntax syntax = 6;
+}
+
+message Field {
+
+    Kind kind = 1;
+    Cardinality cardinality = 2;
+    int32 number = 3;
+    string name = 4;
+    string type_url = 6;
+    int32 oneof_index = 7;
+    bool packed = 8;
+    repeated Option options = 9;
+    string json_name = 10;
+    string default_value = 11;
+
+    enum Kind {
+
+        TYPE_UNKNOWN = 0;
+        TYPE_DOUBLE = 1;
+        TYPE_FLOAT = 2;
+        TYPE_INT64 = 3;
+        TYPE_UINT64 = 4;
+        TYPE_INT32 = 5;
+        TYPE_FIXED64 = 6;
+        TYPE_FIXED32 = 7;
+        TYPE_BOOL = 8;
+        TYPE_STRING = 9;
+        TYPE_GROUP = 10;
+        TYPE_MESSAGE = 11;
+        TYPE_BYTES = 12;
+        TYPE_UINT32 = 13;
+        TYPE_ENUM = 14;
+        TYPE_SFIXED32 = 15;
+        TYPE_SFIXED64 = 16;
+        TYPE_SINT32 = 17;
+        TYPE_SINT64 = 18;
+    }
+
+    enum Cardinality {
+
+        CARDINALITY_UNKNOWN = 0;
+        CARDINALITY_OPTIONAL = 1;
+        CARDINALITY_REQUIRED = 2;
+        CARDINALITY_REPEATED = 3;
+    }
+}
+
+message Enum {
+
+    string name = 1;
+    repeated EnumValue enumvalue = 2;
+    repeated Option options = 3;
+    SourceContext source_context = 4;
+    Syntax syntax = 5;
+}
+
+message EnumValue {
+
+    string name = 1;
+    int32 number = 2;
+    repeated Option options = 3;
+}
+
+message Option {
+
+    string name = 1;
+    Any value = 2;
+}
+
+enum Syntax {
+
+    SYNTAX_PROTO2 = 0;
+    SYNTAX_PROTO3 = 1;
+}

node_modules/@apollo/protobufjs/index.js

@@ -0,0 +1,4 @@
+// full library entry point.
+
+"use strict";
+module.exports = require("./src/index");

node_modules/@apollo/protobufjs/light.d.ts

@@ -0,0 +1,2 @@
+export as namespace protobuf;
+export * from "./index";

node_modules/@apollo/protobufjs/light.js

@@ -0,0 +1,4 @@
+// light library entry point.
+
+"use strict";
+module.exports = require("./src/index-light");

node_modules/@apollo/protobufjs/minimal.d.ts

@@ -0,0 +1,2 @@
+export as namespace protobuf;
+export * from "./index";

node_modules/@apollo/protobufjs/minimal.js

@@ -0,0 +1,4 @@
+// minimal library entry point.
+
+"use strict";
+module.exports = require("./src/index-minimal");