ts-proto 1.96.0 → 1.97.2

package/CHANGELOG.md

@@ -1,3 +1,31 @@
+## [1.97.2](https://github.com/stephenh/ts-proto/compare/v1.97.1...v1.97.2) (2022-01-06)
+
+
+### Performance Improvements
+
+* fromJSON returns object literal to allow v8 optimizations ([#463](https://github.com/stephenh/ts-proto/issues/463)) ([5fcd05b](https://github.com/stephenh/ts-proto/commit/5fcd05b79e7c02547c4b6db46fae7a7202f97629))
+
+## [1.97.1](https://github.com/stephenh/ts-proto/compare/v1.97.0...v1.97.1) (2022-01-05)
+
+
+### Bug Fixes
+
+* oneof=union breaks wrapper types [#458](https://github.com/stephenh/ts-proto/issues/458) ([#462](https://github.com/stephenh/ts-proto/issues/462)) ([dd16992](https://github.com/stephenh/ts-proto/commit/dd16992a409f24e88e3a142830cd0745f50dbd10))
+
+# [1.97.0](https://github.com/stephenh/ts-proto/compare/v1.96.1...v1.97.0) (2021-12-30)
+
+
+### Features
+
+* add an option to disable Exact types ([#456](https://github.com/stephenh/ts-proto/issues/456)) ([9c53d7e](https://github.com/stephenh/ts-proto/commit/9c53d7efb0252c7ea0af85a5d161ff94bcd69760))
+
+## [1.96.1](https://github.com/stephenh/ts-proto/compare/v1.96.0...v1.96.1) (2021-12-28)
+
+
+### Performance Improvements
+
+* optimize object creation in `decode`, `fromJSON` and `fromPartial` ([#457](https://github.com/stephenh/ts-proto/issues/457)) ([70832d3](https://github.com/stephenh/ts-proto/commit/70832d33bae82ecb3c5f87845d14e992a13437e4))
+
 # [1.96.0](https://github.com/stephenh/ts-proto/compare/v1.95.1...v1.96.0) (2021-12-24)
 
 

package/README.markdown

@@ -5,7 +5,7 @@
 
 > `ts-proto` transforms your `.proto` files into strongly-typed, idiomatic TypeScript files!
 
-(Note, if you're a new user of ts-proto and using a modern TS setup with `esModuleInterop`, you need to also pass that as a `ts_proto_opt`.)
+(Note, if you're a new user of ts-proto and using a modern TS setup with `esModuleInterop`, or want to use ts-proto in ESM / snowpack / vite, you need to also pass that as a `ts_proto_opt`.)
 
 ## Table of contents
 
@@ -350,6 +350,10 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=enumsAsLiterals=true`, the generated enum types will be enum-ish object with `as const`.
 
+- With `--ts_proto_opt=useExactTypes=false`, the generated `fromPartial` method will not use Exact types.
+  
+  The default behavior is `useExactTypes=true`, which makes `fromPartial` use Exact type for its argument to make TypeScript reject any unknown properties.
+
 ### Only Types
 
 If you're looking for `ts-proto` to generate only types for your Protobuf types then passing all three of `outputEncodeMethods`, `outputJsonMethods`, and `outputClientImpl` as `false` is probably what you want, i.e.:

package/build/main.js

@@ -70,7 +70,7 @@ function generateFile(ctx, fileDesc) {
         // then add the encoder/decoder/base instance
         visit_1.visit(fileDesc, sourceInfo, (fullName, message, sInfo, fullProtoTypeName) => {
             const fullTypeName = utils_1.maybePrefixPackage(fileDesc, fullProtoTypeName);
-            chunks.push(generateBaseInstance(ctx, fullName, message, fullTypeName));
+            chunks.push(generateBaseInstanceFactory(ctx, fullName, message, fullTypeName));
             const staticMembers = [];
             if (options.outputTypeRegistry) {
                 staticMembers.push(ts_poet_1.code `$type: '${fullTypeName}' as const`);
@@ -86,8 +86,8 @@ function generateFile(ctx, fileDesc) {
             if (options.outputPartialMethods) {
                 staticMembers.push(generateFromPartial(ctx, fullName, message));
             }
-            staticMembers.push(...generateWrap(fullTypeName));
-            staticMembers.push(...generateUnwrap(fullTypeName));
+            staticMembers.push(...generateWrap(ctx, fullTypeName));
+            staticMembers.push(...generateUnwrap(ctx, fullTypeName));
             chunks.push(ts_poet_1.code `
           export const ${ts_poet_1.def(fullName)} = {
             ${ts_poet_1.joinCode(staticMembers, { on: ',\n\n' })}
@@ -195,6 +195,7 @@ function makeUtils(options) {
         ...makeDeepPartial(options, longs),
         ...makeTimestampMethods(options, longs),
         ...longs,
+        ...makeComparisonUtils(),
     };
 }
 exports.makeUtils = makeUtils;
@@ -396,6 +397,17 @@ function makeTimestampMethods(options, longs) {
       `);
     return { toTimestamp, fromTimestamp, fromJsonTimestamp };
 }
+function makeComparisonUtils() {
+    const isObject = ts_poet_1.conditionalOutput('isObject', ts_poet_1.code `
+    function isObject(value: any): boolean {
+      return typeof value === 'object' && value !== null;
+    }`);
+    const isSet = ts_poet_1.conditionalOutput('isSet', ts_poet_1.code `
+    function isSet(value: any): boolean {
+      return value !== null && value !== undefined;
+    }`);
+    return { isObject, isSet };
+}
 // Create the interface with properties
 function generateInterfaceDeclaration(ctx, fullName, messageDesc, sourceInfo, fullTypeName) {
     var _a;
@@ -460,20 +472,39 @@ function generateOneofProperty(ctx, messageDesc, oneofIndex, sourceInfo) {
     return prop;
     */
 }
-// Create a 'base' instance with default values for decode to use as a prototype
-function generateBaseInstance(ctx, fullName, messageDesc, fullTypeName) {
-    const fields = messageDesc.field
-        .filter((field) => !types_1.isWithinOneOf(field))
-        .map((field) => [field, types_1.defaultValue(ctx, field)])
-        .filter(([field, val]) => val !== 'undefined' && !types_1.isBytes(field))
-        .map(([field, val]) => {
+// Create a function that constructs 'base' instance with default values for decode to use as a prototype
+function generateBaseInstanceFactory(ctx, fullName, messageDesc, fullTypeName) {
+    const fields = [];
+    // When oneof=unions, we generate a single property with an ADT per `oneof` clause.
+    const processedOneofs = new Set();
+    for (const field of messageDesc.field) {
+        if (types_1.isWithinOneOfThatShouldBeUnion(ctx.options, field)) {
+            const { oneofIndex } = field;
+            if (!processedOneofs.has(oneofIndex)) {
+                processedOneofs.add(oneofIndex);
+                const name = case_1.maybeSnakeToCamel(messageDesc.oneofDecl[oneofIndex].name, ctx.options);
+                fields.push(ts_poet_1.code `${name}: undefined`);
+            }
+            continue;
+        }
         const name = case_1.maybeSnakeToCamel(field.name, ctx.options);
-        return ts_poet_1.code `${name}: ${val}`;
-    });
+        const val = types_1.isWithinOneOf(field)
+            ? 'undefined'
+            : types_1.isMapType(ctx, messageDesc, field)
+                ? '{}'
+                : types_1.isRepeated(field)
+                    ? '[]'
+                    : types_1.defaultValue(ctx, field);
+        fields.push(ts_poet_1.code `${name}: ${val}`);
+    }
     if (ctx.options.outputTypeRegistry) {
         fields.unshift(ts_poet_1.code `$type: '${fullTypeName}'`);
     }
-    return ts_poet_1.code `const base${fullName}: object = { ${ts_poet_1.joinCode(fields, { on: ',' })} };`;
+    return ts_poet_1.code `
+    function createBase${fullName}(): ${fullName} {
+      return { ${ts_poet_1.joinCode(fields, { on: ',' })} };
+    }
+  `;
 }
 /** Creates a function to decode a message by loop overing the tags. */
 function generateDecode(ctx, fullName, messageDesc) {
@@ -487,22 +518,8 @@ function generateDecode(ctx, fullName, messageDesc) {
     ): ${fullName} {
       const reader = input instanceof ${Reader} ? input : new ${Reader}(input);
       let end = length === undefined ? reader.len : reader.pos + length;
-      const message = { ...base${fullName} } as ${fullName};
+      const message = createBase${fullName}();
   `);
-    // initialize all lists
-    messageDesc.field.filter(types_1.isRepeated).forEach((field) => {
-        const name = case_1.maybeSnakeToCamel(field.name, options);
-        const value = types_1.isMapType(ctx, messageDesc, field) ? '{}' : '[]';
-        chunks.push(ts_poet_1.code `message.${name} = ${value};`);
-    });
-    // initialize all buffers
-    messageDesc.field
-        .filter((field) => !types_1.isRepeated(field) && !types_1.isWithinOneOf(field) && types_1.isBytes(field))
-        .forEach((field) => {
-        const value = options.env === options_1.EnvOption.NODE ? 'Buffer.alloc(0)' : 'new Uint8Array()';
-        const name = case_1.maybeSnakeToCamel(field.name, options);
-        chunks.push(ts_poet_1.code `message.${name} = ${value};`);
-    });
     // start the tag loop
     chunks.push(ts_poet_1.code `
     while (reader.pos < end) {
@@ -567,28 +584,29 @@ function generateDecode(ctx, fullName, messageDesc) {
         }
         // and then use the snippet to handle repeated fields if necessary
         if (types_1.isRepeated(field)) {
+            const maybeNonNullAssertion = ctx.options.useOptionals === 'all' ? '!' : '';
             if (types_1.isMapType(ctx, messageDesc, field)) {
                 // We need a unique const within the `cast` statement
                 const varName = `entry${field.number}`;
                 chunks.push(ts_poet_1.code `
           const ${varName} = ${readSnippet};
           if (${varName}.value !== undefined) {
-            message.${fieldName}[${varName}.key] = ${varName}.value;
+            message.${fieldName}${maybeNonNullAssertion}[${varName}.key] = ${varName}.value;
           }
         `);
             }
             else if (types_1.packedType(field.type) === undefined) {
-                chunks.push(ts_poet_1.code `message.${fieldName}.push(${readSnippet});`);
+                chunks.push(ts_poet_1.code `message.${fieldName}${maybeNonNullAssertion}.push(${readSnippet});`);
             }
             else {
                 chunks.push(ts_poet_1.code `
           if ((tag & 7) === 2) {
             const end2 = reader.uint32() + reader.pos;
             while (reader.pos < end2) {
-              message.${fieldName}.push(${readSnippet});
+              message.${fieldName}${maybeNonNullAssertion}.push(${readSnippet});
             }
           } else {
-            message.${fieldName}.push(${readSnippet});
+            message.${fieldName}${maybeNonNullAssertion}.push(${readSnippet});
           }
         `);
             }
@@ -796,16 +814,21 @@ function generateEncode(ctx, fullName, messageDesc) {
 function generateFromJson(ctx, fullName, messageDesc) {
     const { options, utils, typeMap } = ctx;
     const chunks = [];
+    const choiceFieldChunks = [];
     // create the basic function declaration
     chunks.push(ts_poet_1.code `
     fromJSON(${messageDesc.field.length > 0 ? 'object' : '_'}: any): ${fullName} {
-      const message = { ...base${fullName} } as ${fullName};
+      return {
   `);
+    if (ctx.options.outputTypeRegistry) {
+        chunks.push(ts_poet_1.code `$type: ${fullName}.$type,`);
+    }
+    const oneofFieldsCases = messageDesc.oneofDecl.map((oneof, oneofIndex) => messageDesc.field.filter(types_1.isWithinOneOf).filter((field) => field.oneofIndex === oneofIndex));
     // add a check for each incoming field
     messageDesc.field.forEach((field) => {
         const fieldName = case_1.maybeSnakeToCamel(field.name, options);
         const jsonName = utils_1.determineFieldJsonName(field, options);
-        // get a generic 'reader.doSomething' bit that is specific to the basic type
+        // get code that extracts value from incoming object
         const readSnippet = (from) => {
             if (types_1.isEnum(field)) {
                 const fromJson = types_1.getEnumMethod(ctx, field.typeName, 'FromJSON');
@@ -840,6 +863,9 @@ function generateFromJson(ctx, fullName, messageDesc) {
             else if (types_1.isAnyValueType(field) || types_1.isStructType(field)) {
                 return ts_poet_1.code `${from}`;
             }
+            else if (types_1.isListValueType(field)) {
+                return ts_poet_1.code `[...${from}]`;
+            }
             else if (types_1.isValueType(ctx, field)) {
                 const valueType = types_1.valueTypeName(ctx, field.typeName);
                 if (types_1.isLongValueType(field) && options.forceLong === options_1.LongOption.LONG) {
@@ -848,9 +874,6 @@ function generateFromJson(ctx, fullName, messageDesc) {
                 else if (types_1.isBytesValueType(field)) {
                     return ts_poet_1.code `new ${case_1.capitalize(valueType.toCodeString())}(${from})`;
                 }
-                else if (types_1.isListValueType(field)) {
-                    return ts_poet_1.code `[...${from}]`;
-                }
                 else {
                     return ts_poet_1.code `${case_1.capitalize(valueType.toCodeString())}(${from})`;
                 }
@@ -913,56 +936,71 @@ function generateFromJson(ctx, fullName, messageDesc) {
                 const fieldType = types_1.toTypeName(ctx, messageDesc, field);
                 const i = maybeCastToNumber(ctx, messageDesc, field, 'key');
                 chunks.push(ts_poet_1.code `
-          message.${fieldName} = Object.entries(object.${jsonName} ?? {}).reduce<${fieldType}>((acc, [key, value]) => {
-            acc[${i}] = ${readSnippet('value')};
-            return acc;
-          }, {});
-        `);
-            }
-            else if (types_1.isAnyValueType(field)) {
-                chunks.push(ts_poet_1.code `
-          message.${fieldName} = Array.isArray(object?.${jsonName}) ? [...object.${jsonName}] : [];
+          ${fieldName}: ${ctx.utils.isObject}(object.${jsonName})
+            ? Object.entries(object.${jsonName}).reduce<${fieldType}>((acc, [key, value]) => {
+                acc[${i}] = ${readSnippet('value')};
+                return acc;
+              }, {})
+            : {},
         `);
             }
             else {
-                // Explicit `any` type required to make TS with noImplicitAny happy. `object` is also `any` here.
-                chunks.push(ts_poet_1.code `
-          message.${fieldName} = (object.${jsonName} ?? []).map((e: any) => ${readSnippet('e')});
-        `);
+                const readValueSnippet = readSnippet('e');
+                if (readValueSnippet.toString() === ts_poet_1.code `e`.toString()) {
+                    chunks.push(ts_poet_1.code `${fieldName}: Array.isArray(object?.${jsonName}) ? [...object.${jsonName}] : [],`);
+                }
+                else {
+                    // Explicit `any` type required to make TS with noImplicitAny happy. `object` is also `any` here.
+                    chunks.push(ts_poet_1.code `
+            ${fieldName}: Array.isArray(object?.${jsonName}) ? object.${jsonName}.map((e: any) => ${readValueSnippet}): [],
+          `);
+                }
             }
         }
         else if (types_1.isWithinOneOfThatShouldBeUnion(options, field)) {
-            chunks.push(ts_poet_1.code `if (object.${jsonName} !== undefined && object.${jsonName} !== null) {`);
-            const oneofName = case_1.maybeSnakeToCamel(messageDesc.oneofDecl[field.oneofIndex].name, options);
-            chunks.push(ts_poet_1.code `
-        message.${oneofName} = { $case: '${fieldName}', ${fieldName}: ${readSnippet(`object.${jsonName}`)} }
-      `);
-            chunks.push(ts_poet_1.code `}`);
+            const cases = oneofFieldsCases[field.oneofIndex];
+            const firstCase = cases[0];
+            const lastCase = cases[cases.length - 1];
+            if (field === firstCase) {
+                const fieldName = case_1.maybeSnakeToCamel(messageDesc.oneofDecl[field.oneofIndex].name, options);
+                chunks.push(ts_poet_1.code `${fieldName}: `);
+            }
+            const ternaryIf = ts_poet_1.code `${ctx.utils.isSet}(object.${jsonName})`;
+            const ternaryThen = ts_poet_1.code `{ $case: '${fieldName}', ${fieldName}: ${readSnippet(`object.${jsonName}`)}`;
+            chunks.push(ts_poet_1.code `${ternaryIf} ? ${ternaryThen}} : `);
+            if (field === lastCase) {
+                chunks.push(ts_poet_1.code `undefined,`);
+            }
         }
         else if (types_1.isAnyValueType(field)) {
-            chunks.push(ts_poet_1.code `message.${fieldName} = object.${fieldName};`);
+            chunks.push(ts_poet_1.code `${fieldName}: ${ctx.utils.isSet}(object?.${jsonName})
+        ? ${readSnippet(`object.${jsonName}`)}
+        : undefined,
+      `);
         }
         else if (types_1.isStructType(field)) {
-            chunks.push(ts_poet_1.code `message.${fieldName} = typeof(object.${fieldName}) === 'object' ? object.${fieldName} : undefined;`);
+            chunks.push(ts_poet_1.code `${fieldName}: ${ctx.utils.isObject}(object.${jsonName})
+          ? ${readSnippet(`object.${jsonName}`)}
+          : undefined,`);
         }
         else if (types_1.isListValueType(field)) {
             chunks.push(ts_poet_1.code `
-        message.${fieldName} = Array.isArray(object?.${fieldName})
-          ? ${readSnippet(`object.${fieldName}`)}
-          : ${'undefined'};
+        ${fieldName}: Array.isArray(object.${jsonName})
+          ? ${readSnippet(`object.${jsonName}`)}
+          : undefined,
       `);
         }
         else {
             const fallback = types_1.isWithinOneOf(field) ? 'undefined' : types_1.defaultValue(ctx, field);
             chunks.push(ts_poet_1.code `
-        message.${fieldName} = (object.${jsonName} !== undefined && object.${jsonName} !== null)
+        ${fieldName}: ${ctx.utils.isSet}(object.${jsonName})
           ? ${readSnippet(`object.${jsonName}`)}
-          : ${fallback};
+          : ${fallback},
       `);
         }
     });
     // and then wrap up the switch/while/return
-    chunks.push(ts_poet_1.code `return message`);
+    chunks.push(ts_poet_1.code `};`);
     chunks.push(ts_poet_1.code `}`);
     return ts_poet_1.joinCode(chunks, { on: '\n' });
 }
@@ -1095,13 +1133,19 @@ function generateToJson(ctx, fullName, messageDesc) {
 function generateFromPartial(ctx, fullName, messageDesc) {
     const { options, utils, typeMap } = ctx;
     const chunks = [];
-    const Timestamp = utils_1.impProto(options, 'google/protobuf/timestamp', 'Timestamp');
     // create the basic function declaration
     const paramName = messageDesc.field.length > 0 ? 'object' : '_';
-    chunks.push(ts_poet_1.code `
-    fromPartial<I extends ${utils.Exact}<${utils.DeepPartial}<${fullName}>, I>>(${paramName}: I): ${fullName} {
-      const message = { ...base${fullName} } as ${fullName};
-  `);
+    if (ctx.options.useExactTypes) {
+        chunks.push(ts_poet_1.code `
+      fromPartial<I extends ${utils.Exact}<${utils.DeepPartial}<${fullName}>, I>>(${paramName}: I): ${fullName} {
+    `);
+    }
+    else {
+        chunks.push(ts_poet_1.code `
+      fromPartial(${paramName}: ${utils.DeepPartial}<${fullName}>): ${fullName} {
+    `);
+    }
+    chunks.push(ts_poet_1.code `const message = createBase${fullName}();`);
     // add a check for each incoming field
     messageDesc.field.forEach((field) => {
         const fieldName = case_1.maybeSnakeToCamel(field.name, options);
@@ -1211,7 +1255,7 @@ function generateFromPartial(ctx, fullName, messageDesc) {
     chunks.push(ts_poet_1.code `}`);
     return ts_poet_1.joinCode(chunks, { on: '\n' });
 }
-function generateWrap(fullProtoTypeName) {
+function generateWrap(ctx, fullProtoTypeName) {
     const chunks = [];
     if (types_1.isStructTypeName(fullProtoTypeName)) {
         chunks.push(ts_poet_1.code `wrap(object: {[key: string]: any} | undefined): Struct {
@@ -1225,7 +1269,29 @@ function generateWrap(fullProtoTypeName) {
     }`);
     }
     if (types_1.isAnyValueTypeName(fullProtoTypeName)) {
-        chunks.push(ts_poet_1.code `wrap(value: any): Value {
+        if (ctx.options.oneof === options_1.OneofOption.UNIONS) {
+            chunks.push(ts_poet_1.code `wrap(value: any): Value {
+      if (value === null) {
+        return {kind: {$case: 'nullValue', nullValue: NullValue.NULL_VALUE}};
+      } else if (typeof value === 'boolean') {
+        return {kind: {$case: 'boolValue', boolValue: value}};
+      } else if (typeof value === 'number') {
+        return {kind: {$case: 'numberValue', numberValue: value}};
+      } else if (typeof value === 'string') {
+        return {kind: {$case: 'stringValue', stringValue: value}};
+      } else if (Array.isArray(value)) {
+        return {kind: {$case: 'listValue', listValue: value}};
+      } else if (typeof value === 'object') {
+        return {kind: {$case: 'structValue', structValue: value}};
+      } else if (typeof value === 'undefined') {
+        return {} as Value;
+      } else {
+        throw new Error('Unsupported any value type: ' + typeof value);
+      }
+    }`);
+        }
+        else {
+            chunks.push(ts_poet_1.code `wrap(value: any): Value {
       if (value === null) {
         return {nullValue: NullValue.NULL_VALUE} as Value;
       } else if (typeof value === 'boolean') {
@@ -1244,15 +1310,16 @@ function generateWrap(fullProtoTypeName) {
         throw new Error('Unsupported any value type: ' + typeof value);
       }
     }`);
+        }
     }
     if (types_1.isListValueTypeName(fullProtoTypeName)) {
-        chunks.push(ts_poet_1.code `wrap(value: Array<any>): ListValue {
-      return {values: value};
+        chunks.push(ts_poet_1.code `wrap(value: Array<any> | undefined): ListValue {
+      return {values: value ?? []};
     }`);
     }
     return chunks;
 }
-function generateUnwrap(fullProtoTypeName) {
+function generateUnwrap(ctx, fullProtoTypeName) {
     const chunks = [];
     if (types_1.isStructTypeName(fullProtoTypeName)) {
         chunks.push(ts_poet_1.code `unwrap(message: Struct): {[key: string]: any} {
@@ -1264,7 +1331,27 @@ function generateUnwrap(fullProtoTypeName) {
     }`);
     }
     if (types_1.isAnyValueTypeName(fullProtoTypeName)) {
-        chunks.push(ts_poet_1.code `unwrap(message: Value): string | number | boolean | Object | null | Array<any> | undefined {
+        if (ctx.options.oneof === options_1.OneofOption.UNIONS) {
+            chunks.push(ts_poet_1.code `unwrap(message: Value): string | number | boolean | Object | null | Array<any> | undefined {
+        if (message.kind?.$case === 'nullValue') {
+          return null;
+        } else if (message.kind?.$case === 'numberValue') {
+          return message.kind?.numberValue;
+        } else if (message.kind?.$case === 'stringValue') {
+          return message.kind?.stringValue;
+        } else if (message.kind?.$case === 'boolValue') {
+          return message.kind?.boolValue;
+        } else if (message.kind?.$case === 'structValue') {
+          return message.kind?.structValue;
+        } else if (message.kind?.$case === 'listValue') {
+          return message.kind?.listValue;
+        } else {
+          return undefined;
+        }
+    }`);
+        }
+        else {
+            chunks.push(ts_poet_1.code `unwrap(message: Value): string | number | boolean | Object | null | Array<any> | undefined {
       if (message?.stringValue !== undefined) {
         return message.stringValue;
       } else if (message?.numberValue !== undefined) {
@@ -1280,6 +1367,7 @@ function generateUnwrap(fullProtoTypeName) {
       }
       return undefined;
     }`);
+        }
     }
     if (types_1.isListValueTypeName(fullProtoTypeName)) {
         chunks.push(ts_poet_1.code `unwrap(message: ListValue): Array<any> {

package/build/options.js

@@ -61,6 +61,7 @@ function defaultOptions() {
         outputSchema: false,
         onlyTypes: false,
         emitImportedFiles: true,
+        useExactTypes: true,
     };
 }
 exports.defaultOptions = defaultOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-proto",
-  "version": "1.96.0",
+  "version": "1.97.2",
   "description": "",
   "main": "build/plugin.js",
   "repository": "github:stephenh/ts-proto",