quicktype 17.0.5 → 18.0.0

package/dist/quicktype-core/GraphRewriting.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphRewriteBuilder = exports.GraphRemapBuilder = exports.BaseGraphRewriteBuilder = exports.TypeReconstituter = void 0;
 const collection_utils_1 = require("collection-utils");
 const TypeUtils_1 = require("./TypeUtils");
 const TypeGraph_1 = require("./TypeGraph");
@@ -7,33 +8,38 @@ const TypeAttributes_1 = require("./attributes/TypeAttributes");
 const Support_1 = require("./support/Support");
 const TypeBuilder_1 = require("./TypeBuilder");
 class TypeReconstituter {
+    _typeBuilder;
+    _makeClassUnique;
+    _typeAttributes;
+    _forwardingRef;
+    _register;
+    _wasUsed = false;
+    _typeRef = undefined;
     constructor(_typeBuilder, _makeClassUnique, _typeAttributes, _forwardingRef, _register) {
         this._typeBuilder = _typeBuilder;
         this._makeClassUnique = _makeClassUnique;
         this._typeAttributes = _typeAttributes;
         this._forwardingRef = _forwardingRef;
         this._register = _register;
-        this._wasUsed = false;
-        this._typeRef = undefined;
     }
     builderForNewType() {
-        Support_1.assert(!this._wasUsed, "TypeReconstituter used more than once");
+        (0, Support_1.assert)(!this._wasUsed, "TypeReconstituter used more than once");
         this._wasUsed = true;
         return this._typeBuilder;
     }
     builderForSetting() {
-        Support_1.assert(this._wasUsed && this._typeRef !== undefined, "Can't set type members before constructing a type");
+        (0, Support_1.assert)(this._wasUsed && this._typeRef !== undefined, "Can't set type members before constructing a type");
         return this._typeBuilder;
     }
     getResult() {
         if (this._typeRef === undefined) {
-            return Support_1.panic("Type was not reconstituted");
+            return (0, Support_1.panic)("Type was not reconstituted");
         }
         return this._typeRef;
     }
     // FIXME: Do registration automatically.
     register(tref) {
-        Support_1.assert(this._typeRef === undefined, "Cannot register a type twice");
+        (0, Support_1.assert)(this._typeRef === undefined, "Cannot register a type twice");
         this._typeRef = tref;
         this._register(tref);
     }
@@ -42,8 +48,8 @@ class TypeReconstituter {
         this.register(tref);
     }
     lookup(trefs) {
-        Support_1.assert(!this._wasUsed, "Cannot lookup constituents after building type");
-        if (TypeGraph_1.isTypeRef(trefs)) {
+        (0, Support_1.assert)(!this._wasUsed, "Cannot lookup constituents after building type");
+        if ((0, TypeGraph_1.isTypeRef)(trefs)) {
             return this._typeBuilder.lookupTypeRefs([trefs], undefined, false);
         }
         else {
@@ -57,7 +63,7 @@ class TypeReconstituter {
         const resultValues = this.lookup(trefs.values());
         if (resultValues === undefined)
             return undefined;
-        Support_1.assert(resultValues.length === trefs.size, "Didn't get back the correct number of types");
+        (0, Support_1.assert)(resultValues.length === trefs.size, "Didn't get back the correct number of types");
         const result = new Map();
         let i = 0;
         for (const k of trefs.keys()) {
@@ -67,8 +73,8 @@ class TypeReconstituter {
         return result;
     }
     reconstitute(trefs) {
-        Support_1.assert(this._wasUsed, "Cannot reconstitute constituents before building type");
-        if (TypeGraph_1.isTypeRef(trefs)) {
+        (0, Support_1.assert)(this._wasUsed, "Cannot reconstitute constituents before building type");
+        if ((0, TypeGraph_1.isTypeRef)(trefs)) {
             return this._typeBuilder.reconstituteTypeRef(trefs);
         }
         else {
@@ -76,7 +82,7 @@ class TypeReconstituter {
         }
     }
     reconstituteMap(trefs) {
-        return collection_utils_1.mapMap(trefs, tref => this._typeBuilder.reconstituteTypeRef(tref));
+        return (0, collection_utils_1.mapMap)(trefs, tref => this._typeBuilder.reconstituteTypeRef(tref));
     }
     getPrimitiveType(kind) {
         this.register(this.builderForNewType().getPrimitiveType(kind, this._typeAttributes, this._forwardingRef));
@@ -139,13 +145,15 @@ class TypeReconstituter {
 }
 exports.TypeReconstituter = TypeReconstituter;
 class BaseGraphRewriteBuilder extends TypeBuilder_1.TypeBuilder {
+    originalGraph;
+    debugPrint;
+    reconstitutedTypes = new Map();
+    _lostTypeAttributes = false;
+    _printIndent = 0;
     constructor(originalGraph, stringTypeMapping, alphabetizeProperties, graphHasProvenanceAttributes, debugPrint) {
         super(originalGraph.serial + 1, stringTypeMapping, alphabetizeProperties, false, false, graphHasProvenanceAttributes);
         this.originalGraph = originalGraph;
         this.debugPrint = debugPrint;
-        this.reconstitutedTypes = new Map();
-        this._lostTypeAttributes = false;
-        this._printIndent = 0;
     }
     withForwardingRef(maybeForwardingRef, typeCreator) {
         if (maybeForwardingRef !== undefined) {
@@ -153,7 +161,7 @@ class BaseGraphRewriteBuilder extends TypeBuilder_1.TypeBuilder {
         }
         const forwardingRef = this.reserveTypeRef();
         const actualRef = typeCreator(forwardingRef);
-        Support_1.assert(actualRef === forwardingRef, "Type creator didn't return its forwarding ref");
+        (0, Support_1.assert)(actualRef === forwardingRef, "Type creator didn't return its forwarding ref");
         return actualRef;
     }
     reconstituteType(t, attributes, forwardingRef) {
@@ -170,22 +178,22 @@ class BaseGraphRewriteBuilder extends TypeBuilder_1.TypeBuilder {
         return this.forceReconstituteTypeRef(originalRef, attributes, maybeForwardingRef);
     }
     reconstituteTypeAttributes(attributes) {
-        return collection_utils_1.mapMap(attributes, (v, a) => a.reconstitute(this, v));
+        return (0, collection_utils_1.mapMap)(attributes, (v, a) => a.reconstitute(this, v));
     }
     assertTypeRefsToReconstitute(typeRefs, forwardingRef) {
-        Support_1.assert(typeRefs.length > 0, "Must have at least one type to reconstitute");
+        (0, Support_1.assert)(typeRefs.length > 0, "Must have at least one type to reconstitute");
         for (const originalRef of typeRefs) {
-            TypeGraph_1.assertTypeRefGraph(originalRef, this.originalGraph);
+            (0, TypeGraph_1.assertTypeRefGraph)(originalRef, this.originalGraph);
         }
         if (forwardingRef !== undefined) {
-            TypeGraph_1.assertTypeRefGraph(forwardingRef, this.typeGraph);
+            (0, TypeGraph_1.assertTypeRefGraph)(forwardingRef, this.typeGraph);
         }
     }
     changeDebugPrintIndent(delta) {
         this._printIndent += delta;
     }
     get debugPrintIndentation() {
-        return Support_1.indentationString(this._printIndent);
+        return (0, Support_1.indentationString)(this._printIndent);
     }
     finish() {
         for (const [name, t] of this.originalGraph.topLevels) {
@@ -202,10 +210,11 @@ class BaseGraphRewriteBuilder extends TypeBuilder_1.TypeBuilder {
 }
 exports.BaseGraphRewriteBuilder = BaseGraphRewriteBuilder;
 class GraphRemapBuilder extends BaseGraphRewriteBuilder {
+    _map;
+    _attributeSources = new Map();
     constructor(originalGraph, stringTypeMapping, alphabetizeProperties, graphHasProvenanceAttributes, _map, debugPrintRemapping) {
         super(originalGraph, stringTypeMapping, alphabetizeProperties, graphHasProvenanceAttributes, debugPrintRemapping);
         this._map = _map;
-        this._attributeSources = new Map();
         for (const [source, target] of _map) {
             let maybeSources = this._attributeSources.get(target);
             if (maybeSources === undefined) {
@@ -219,23 +228,23 @@ class GraphRemapBuilder extends BaseGraphRewriteBuilder {
         return undefined;
     }
     getMapTarget(tref) {
-        const maybeType = this._map.get(TypeGraph_1.derefTypeRef(tref, this.originalGraph));
+        const maybeType = this._map.get((0, TypeGraph_1.derefTypeRef)(tref, this.originalGraph));
         if (maybeType === undefined)
             return tref;
-        Support_1.assert(this._map.get(maybeType) === undefined, "We have a type that's remapped to a remapped type");
+        (0, Support_1.assert)(this._map.get(maybeType) === undefined, "We have a type that's remapped to a remapped type");
         return maybeType.typeRef;
     }
     addForwardingIntersection(_forwardingRef, _tref) {
-        return Support_1.panic("We can't add forwarding intersections when we're removing forwarding intersections");
+        return (0, Support_1.panic)("We can't add forwarding intersections when we're removing forwarding intersections");
     }
     lookupTypeRefs(typeRefs, forwardingRef) {
-        Support_1.assert(forwardingRef === undefined, "We can't have a forwarding ref when we remap");
+        (0, Support_1.assert)(forwardingRef === undefined, "We can't have a forwarding ref when we remap");
         this.assertTypeRefsToReconstitute(typeRefs, forwardingRef);
-        const first = this.reconstitutedTypes.get(TypeGraph_1.typeRefIndex(this.getMapTarget(typeRefs[0])));
+        const first = this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(this.getMapTarget(typeRefs[0])));
         if (first === undefined)
             return undefined;
         for (let i = 1; i < typeRefs.length; i++) {
-            const other = this.reconstitutedTypes.get(TypeGraph_1.typeRefIndex(this.getMapTarget(typeRefs[i])));
+            const other = this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(this.getMapTarget(typeRefs[i])));
             if (first !== other)
                 return undefined;
         }
@@ -243,32 +252,32 @@ class GraphRemapBuilder extends BaseGraphRewriteBuilder {
     }
     forceReconstituteTypeRef(originalRef, attributes, maybeForwardingRef) {
         originalRef = this.getMapTarget(originalRef);
-        const index = TypeGraph_1.typeRefIndex(originalRef);
-        Support_1.assert(this.reconstitutedTypes.get(index) === undefined, "Type has already been reconstituted");
-        Support_1.assert(maybeForwardingRef === undefined, "We can't have a forwarding ref when we remap");
+        const index = (0, TypeGraph_1.typeRefIndex)(originalRef);
+        (0, Support_1.assert)(this.reconstitutedTypes.get(index) === undefined, "Type has already been reconstituted");
+        (0, Support_1.assert)(maybeForwardingRef === undefined, "We can't have a forwarding ref when we remap");
         return this.withForwardingRef(undefined, forwardingRef => {
             this.reconstitutedTypes.set(index, forwardingRef);
             if (this.debugPrint) {
-                console.log(`${this.debugPrintIndentation}reconstituting ${index} as ${TypeGraph_1.typeRefIndex(forwardingRef)}`);
+                console.log(`${this.debugPrintIndentation}reconstituting ${index} as ${(0, TypeGraph_1.typeRefIndex)(forwardingRef)}`);
                 this.changeDebugPrintIndent(1);
             }
-            const [originalType, originalAttributes] = TypeGraph_1.typeAndAttributesForTypeRef(originalRef, this.originalGraph);
+            const [originalType, originalAttributes] = (0, TypeGraph_1.typeAndAttributesForTypeRef)(originalRef, this.originalGraph);
             const attributeSources = this._attributeSources.get(originalType);
             if (attributes === undefined) {
                 attributes = TypeAttributes_1.emptyTypeAttributes;
             }
             if (attributeSources === undefined) {
-                attributes = TypeAttributes_1.combineTypeAttributes("union", attributes, this.reconstituteTypeAttributes(originalAttributes));
+                attributes = (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, this.reconstituteTypeAttributes(originalAttributes));
             }
             else {
-                attributes = TypeAttributes_1.combineTypeAttributes("union", attributes, this.reconstituteTypeAttributes(TypeUtils_1.combineTypeAttributesOfTypes("union", attributeSources)));
+                attributes = (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, this.reconstituteTypeAttributes((0, TypeUtils_1.combineTypeAttributesOfTypes)("union", attributeSources)));
             }
             const newAttributes = attributes;
             const reconstituter = new TypeReconstituter(this, this.canonicalOrder, newAttributes, forwardingRef, tref => {
-                Support_1.assert(tref === forwardingRef, "Reconstituted type as a different ref");
+                (0, Support_1.assert)(tref === forwardingRef, "Reconstituted type as a different ref");
                 if (this.debugPrint) {
                     this.changeDebugPrintIndent(-1);
-                    console.log(`${this.debugPrintIndentation}reconstituted ${index} as ${TypeGraph_1.typeRefIndex(tref)}`);
+                    console.log(`${this.debugPrintIndentation}reconstituted ${index} as ${(0, TypeGraph_1.typeRefIndex)(tref)}`);
                 }
             });
             originalType.reconstitute(reconstituter, this.canonicalOrder);
@@ -278,23 +287,25 @@ class GraphRemapBuilder extends BaseGraphRewriteBuilder {
 }
 exports.GraphRemapBuilder = GraphRemapBuilder;
 class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
+    _replacer;
+    _setsToReplaceByMember;
+    _reconstitutedUnions = new collection_utils_1.EqualityMap();
     constructor(originalGraph, stringTypeMapping, alphabetizeProperties, graphHasProvenanceAttributes, setsToReplace, debugPrintReconstitution, _replacer) {
         super(originalGraph, stringTypeMapping, alphabetizeProperties, graphHasProvenanceAttributes, debugPrintReconstitution);
         this._replacer = _replacer;
-        this._reconstitutedUnions = new collection_utils_1.EqualityMap();
         this._setsToReplaceByMember = new Map();
         for (const types of setsToReplace) {
             const set = new Set(types);
             for (const t of set) {
                 const index = t.index;
-                Support_1.assert(!this._setsToReplaceByMember.has(index), "A type is member of more than one set to be replaced");
+                (0, Support_1.assert)(!this._setsToReplaceByMember.has(index), "A type is member of more than one set to be replaced");
                 this._setsToReplaceByMember.set(index, set);
             }
         }
     }
     registerUnion(typeRefs, reconstituted) {
         const set = new Set(typeRefs);
-        Support_1.assert(!this._reconstitutedUnions.has(set), "Cannot register reconstituted set twice");
+        (0, Support_1.assert)(!this._reconstitutedUnions.has(set), "Cannot register reconstituted set twice");
         this._reconstitutedUnions.set(set, reconstituted);
     }
     replaceSet(typesToReplace, maybeForwardingRef) {
@@ -302,29 +313,29 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
             if (this.debugPrint) {
                 console.log(`${this.debugPrintIndentation}replacing set ${Array.from(typesToReplace)
                     .map(t => t.index.toString())
-                    .join(",")} as ${TypeGraph_1.typeRefIndex(forwardingRef)}`);
+                    .join(",")} as ${(0, TypeGraph_1.typeRefIndex)(forwardingRef)}`);
                 this.changeDebugPrintIndent(1);
             }
             for (const t of typesToReplace) {
                 const originalRef = t.typeRef;
-                const index = TypeGraph_1.typeRefIndex(originalRef);
+                const index = (0, TypeGraph_1.typeRefIndex)(originalRef);
                 this.reconstitutedTypes.set(index, forwardingRef);
                 this._setsToReplaceByMember.delete(index);
             }
             const result = this._replacer(typesToReplace, this, forwardingRef);
-            Support_1.assert(result === forwardingRef, "The forwarding ref got lost when replacing");
+            (0, Support_1.assert)(result === forwardingRef, "The forwarding ref got lost when replacing");
             if (this.debugPrint) {
                 this.changeDebugPrintIndent(-1);
                 console.log(`${this.debugPrintIndentation}replaced set ${Array.from(typesToReplace)
                     .map(t => t.index.toString())
-                    .join(",")} as ${TypeGraph_1.typeRefIndex(forwardingRef)}`);
+                    .join(",")} as ${(0, TypeGraph_1.typeRefIndex)(forwardingRef)}`);
             }
             return result;
         });
     }
     forceReconstituteTypeRef(originalRef, attributes, maybeForwardingRef) {
-        const [originalType, originalAttributes] = TypeGraph_1.typeAndAttributesForTypeRef(originalRef, this.originalGraph);
-        const index = TypeGraph_1.typeRefIndex(originalRef);
+        const [originalType, originalAttributes] = (0, TypeGraph_1.typeAndAttributesForTypeRef)(originalRef, this.originalGraph);
+        const index = (0, TypeGraph_1.typeRefIndex)(originalRef);
         if (this.debugPrint) {
             console.log(`${this.debugPrintIndentation}reconstituting ${index}`);
             this.changeDebugPrintIndent(1);
@@ -333,22 +344,22 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
             attributes = this.reconstituteTypeAttributes(originalAttributes);
         }
         else {
-            attributes = TypeAttributes_1.combineTypeAttributes("union", attributes, this.reconstituteTypeAttributes(originalAttributes));
+            attributes = (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, this.reconstituteTypeAttributes(originalAttributes));
         }
         const reconstituter = new TypeReconstituter(this, this.canonicalOrder, attributes, maybeForwardingRef, tref => {
             if (this.debugPrint) {
                 this.changeDebugPrintIndent(-1);
-                console.log(`${this.debugPrintIndentation}reconstituted ${index} as ${TypeGraph_1.typeRefIndex(tref)}`);
+                console.log(`${this.debugPrintIndentation}reconstituted ${index} as ${(0, TypeGraph_1.typeRefIndex)(tref)}`);
             }
             if (maybeForwardingRef !== undefined) {
-                Support_1.assert(tref === maybeForwardingRef, "We didn't pass the forwarding ref");
+                (0, Support_1.assert)(tref === maybeForwardingRef, "We didn't pass the forwarding ref");
             }
             const alreadyReconstitutedType = this.reconstitutedTypes.get(index);
             if (alreadyReconstitutedType === undefined) {
                 this.reconstitutedTypes.set(index, tref);
             }
             else {
-                Support_1.assert(tref === alreadyReconstitutedType, "We reconstituted a type twice differently");
+                (0, Support_1.assert)(tref === alreadyReconstitutedType, "We reconstituted a type twice differently");
             }
         });
         originalType.reconstitute(reconstituter, this.canonicalOrder);
@@ -373,11 +384,11 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
         this.assertTypeRefsToReconstitute(typeRefs, forwardingRef);
         // Check whether we have already reconstituted them.  That means ensuring
         // that they all have the same target type.
-        let maybeRef = this.reconstitutedTypes.get(TypeGraph_1.typeRefIndex(typeRefs[0]));
+        let maybeRef = this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(typeRefs[0]));
         if (maybeRef !== undefined && maybeRef !== forwardingRef) {
             let allEqual = true;
             for (let i = 1; i < typeRefs.length; i++) {
-                if (this.reconstitutedTypes.get(TypeGraph_1.typeRefIndex(typeRefs[i])) !== maybeRef) {
+                if (this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(typeRefs[i])) !== maybeRef) {
                     allEqual = false;
                     break;
                 }
@@ -392,12 +403,12 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
             return this.forwardIfNecessary(forwardingRef, maybeRef);
         }
         // Is this set requested to be replaced?  If not, we're out of options.
-        const maybeSet = this._setsToReplaceByMember.get(TypeGraph_1.typeRefIndex(typeRefs[0]));
+        const maybeSet = this._setsToReplaceByMember.get((0, TypeGraph_1.typeRefIndex)(typeRefs[0]));
         if (maybeSet === undefined) {
             return undefined;
         }
         for (let i = 1; i < typeRefs.length; i++) {
-            if (this._setsToReplaceByMember.get(TypeGraph_1.typeRefIndex(typeRefs[i])) !== maybeSet) {
+            if (this._setsToReplaceByMember.get((0, TypeGraph_1.typeRefIndex)(typeRefs[i])) !== maybeSet) {
                 return undefined;
             }
         }

package/dist/quicktype-core/MakeTransformations.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTransformations = void 0;
 const collection_utils_1 = require("collection-utils");
 const TypeGraph_1 = require("./TypeGraph");
 const Type_1 = require("./Type");
@@ -11,7 +12,7 @@ const Constraints_1 = require("./attributes/Constraints");
 function transformationAttributes(graph, reconstitutedTargetType, transformer, debugPrintTransformations) {
     const transformation = new Transformers_1.Transformation(graph, reconstitutedTargetType, transformer);
     if (debugPrintTransformations) {
-        console.log(`transformation for ${TypeGraph_1.typeRefIndex(reconstitutedTargetType)}:`);
+        console.log(`transformation for ${(0, TypeGraph_1.typeRefIndex)(reconstitutedTargetType)}:`);
         transformation.debugPrint();
         console.log(`reverse:`);
         transformation.reverse.debugPrint();
@@ -25,18 +26,18 @@ function makeEnumTransformer(graph, enumType, stringType, continuation) {
 }
 function replaceUnion(union, builder, forwardingRef, transformedTypes, debugPrintTransformations) {
     const graph = builder.typeGraph;
-    Support_1.assert(union.members.size > 0, "We can't have empty unions");
+    (0, Support_1.assert)(union.members.size > 0, "We can't have empty unions");
     // Type attributes that we lost during reconstitution.
     let additionalAttributes = TypeAttributes_1.emptyTypeAttributes;
     function reconstituteMember(t) {
         // Special handling for some transformed string type kinds: The type in
         // the union must be the target type, so if one already exists, use that
         // one, otherwise make a new one.
-        if (Type_1.isPrimitiveStringTypeKind(t.kind)) {
-            const targetTypeKind = Type_1.targetTypeKindForTransformedStringTypeKind(t.kind);
+        if ((0, Type_1.isPrimitiveStringTypeKind)(t.kind)) {
+            const targetTypeKind = (0, Type_1.targetTypeKindForTransformedStringTypeKind)(t.kind);
             if (targetTypeKind !== undefined) {
                 const targetTypeMember = union.findMember(targetTypeKind);
-                additionalAttributes = TypeAttributes_1.combineTypeAttributes("union", additionalAttributes, t.getAttributes());
+                additionalAttributes = (0, TypeAttributes_1.combineTypeAttributes)("union", additionalAttributes, t.getAttributes());
                 if (targetTypeMember !== undefined) {
                     return builder.reconstituteType(targetTypeMember);
                 }
@@ -45,7 +46,7 @@ function replaceUnion(union, builder, forwardingRef, transformedTypes, debugPrin
         }
         return builder.reconstituteType(t);
     }
-    const reconstitutedMembersByKind = collection_utils_1.mapMapEntries(union.members.entries(), m => [m.kind, reconstituteMember(m)]);
+    const reconstitutedMembersByKind = (0, collection_utils_1.mapMapEntries)(union.members.entries(), m => [m.kind, reconstituteMember(m)]);
     const reconstitutedMemberSet = new Set(reconstitutedMembersByKind.values());
     const haveUnion = reconstitutedMemberSet.size > 1;
     if (!haveUnion) {
@@ -53,9 +54,9 @@ function replaceUnion(union, builder, forwardingRef, transformedTypes, debugPrin
     }
     const reconstitutedTargetType = haveUnion
         ? builder.getUnionType(union.getAttributes(), reconstitutedMemberSet)
-        : Support_1.defined(collection_utils_1.iterableFirst(reconstitutedMemberSet));
+        : (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(reconstitutedMemberSet));
     function memberForKind(kind) {
-        return Support_1.defined(reconstitutedMembersByKind.get(kind));
+        return (0, Support_1.defined)(reconstitutedMembersByKind.get(kind));
     }
     function consumer(memberTypeRef) {
         if (!haveUnion)
@@ -79,7 +80,7 @@ function replaceUnion(union, builder, forwardingRef, transformedTypes, debugPrin
     function transformerForStringType(t) {
         const memberRef = memberForKind(t.kind);
         if (t.kind === "string") {
-            const minMax = Constraints_1.minMaxLengthForType(t);
+            const minMax = (0, Constraints_1.minMaxLengthForType)(t);
             if (minMax === undefined) {
                 return consumer(memberRef);
             }
@@ -93,7 +94,7 @@ function replaceUnion(union, builder, forwardingRef, transformedTypes, debugPrin
             return new Transformers_1.ParseStringTransformer(graph, getStringType(), consumer(memberRef));
         }
     }
-    const stringTypes = collection_utils_1.arraySortByInto(Array.from(union.stringTypeMembers), t => t.kind);
+    const stringTypes = (0, collection_utils_1.arraySortByInto)(Array.from(union.stringTypeMembers), t => t.kind);
     let transformerForString;
     if (stringTypes.length === 0) {
         transformerForString = undefined;
@@ -103,15 +104,15 @@ function replaceUnion(union, builder, forwardingRef, transformedTypes, debugPrin
         transformerForString = new Transformers_1.DecodingTransformer(graph, getStringType(), transformerForStringType(t));
     }
     else {
-        transformerForString = new Transformers_1.DecodingTransformer(graph, getStringType(), new Transformers_1.ChoiceTransformer(graph, getStringType(), stringTypes.map(t => Support_1.defined(transformerForStringType(t)))));
+        transformerForString = new Transformers_1.DecodingTransformer(graph, getStringType(), new Transformers_1.ChoiceTransformer(graph, getStringType(), stringTypes.map(t => (0, Support_1.defined)(transformerForStringType(t)))));
     }
     const transformerForClass = transformerForKind("class");
     const transformerForMap = transformerForKind("map");
-    Support_1.assert(transformerForClass === undefined || transformerForMap === undefined, "Can't have both class and map in a transformed union");
+    (0, Support_1.assert)(transformerForClass === undefined || transformerForMap === undefined, "Can't have both class and map in a transformed union");
     const transformerForObject = transformerForClass !== undefined ? transformerForClass : transformerForMap;
     const transformer = new Transformers_1.DecodingChoiceTransformer(graph, builder.getPrimitiveType("any"), transformerForKind("null"), transformerForKind("integer"), transformerForKind("double"), transformerForKind("bool"), transformerForString, transformerForKind("array"), transformerForObject);
     const attributes = transformationAttributes(graph, reconstitutedTargetType, transformer, debugPrintTransformations);
-    return builder.getPrimitiveType("any", TypeAttributes_1.combineTypeAttributes("union", attributes, additionalAttributes), forwardingRef);
+    return builder.getPrimitiveType("any", (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, additionalAttributes), forwardingRef);
 }
 function replaceArray(arrayType, builder, forwardingRef, debugPrintTransformations) {
     const anyType = builder.getPrimitiveType("any");
@@ -131,14 +132,14 @@ function replaceEnum(enumType, builder, forwardingRef, debugPrintTransformations
 }
 function replaceNumber(t, builder, forwardingRef, debugPrintTransformations) {
     const stringType = builder.getStringType(TypeAttributes_1.emptyTypeAttributes, StringTypes_1.StringTypes.unrestricted);
-    const [min, max] = Support_1.defined(Constraints_1.minMaxValueForType(t));
+    const [min, max] = (0, Support_1.defined)((0, Constraints_1.minMaxValueForType)(t));
     const transformer = new Transformers_1.DecodingTransformer(builder.typeGraph, stringType, new Transformers_1.MinMaxValueTransformer(builder.typeGraph, stringType, undefined, min, max));
     const reconstitutedAttributes = builder.reconstituteTypeAttributes(t.getAttributes());
     const attributes = transformationAttributes(builder.typeGraph, builder.getPrimitiveType("double", reconstitutedAttributes, undefined), transformer, debugPrintTransformations);
     return builder.getPrimitiveType("double", attributes, forwardingRef);
 }
 function replaceString(t, builder, forwardingRef, debugPrintTransformations) {
-    const [min, max] = Support_1.defined(Constraints_1.minMaxLengthForType(t));
+    const [min, max] = (0, Support_1.defined)((0, Constraints_1.minMaxLengthForType)(t));
     const reconstitutedAttributes = builder.reconstituteTypeAttributes(t.getAttributes());
     const stringType = builder.getStringType(TypeAttributes_1.emptyTypeAttributes, StringTypes_1.StringTypes.unrestricted);
     const transformer = new Transformers_1.DecodingTransformer(builder.typeGraph, stringType, new Transformers_1.MinMaxLengthCheckTransformer(builder.typeGraph, stringType, undefined, min, max));
@@ -147,14 +148,14 @@ function replaceString(t, builder, forwardingRef, debugPrintTransformations) {
 }
 function replaceTransformedStringType(t, kind, builder, forwardingRef, debugPrintTransformations) {
     const reconstitutedAttributes = builder.reconstituteTypeAttributes(t.getAttributes());
-    const targetTypeKind = collection_utils_1.withDefault(Type_1.targetTypeKindForTransformedStringTypeKind(kind), kind);
+    const targetTypeKind = (0, collection_utils_1.withDefault)((0, Type_1.targetTypeKindForTransformedStringTypeKind)(kind), kind);
     const stringType = builder.getStringType(TypeAttributes_1.emptyTypeAttributes, StringTypes_1.StringTypes.unrestricted);
     const transformer = new Transformers_1.DecodingTransformer(builder.typeGraph, stringType, new Transformers_1.ParseStringTransformer(builder.typeGraph, stringType, undefined));
     const attributes = transformationAttributes(builder.typeGraph, builder.getPrimitiveType(targetTypeKind, reconstitutedAttributes), transformer, debugPrintTransformations);
     return builder.getStringType(attributes, StringTypes_1.StringTypes.unrestricted, forwardingRef);
 }
 function makeTransformations(ctx, graph, targetLanguage) {
-    const transformedTypes = collection_utils_1.setFilter(graph.allTypesUnordered(), t => {
+    const transformedTypes = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), t => {
         if (targetLanguage.needsTransformerForType(t))
             return true;
         if (!(t instanceof Type_1.UnionType))
@@ -162,10 +163,10 @@ function makeTransformations(ctx, graph, targetLanguage) {
         const stringMembers = t.stringTypeMembers;
         if (stringMembers.size <= 1)
             return false;
-        return collection_utils_1.iterableSome(stringMembers, m => targetLanguage.needsTransformerForType(m));
+        return (0, collection_utils_1.iterableSome)(stringMembers, m => targetLanguage.needsTransformerForType(m));
     });
     function replace(setOfOneUnion, builder, forwardingRef) {
-        const t = Support_1.defined(collection_utils_1.iterableFirst(setOfOneUnion));
+        const t = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(setOfOneUnion));
         if (t instanceof Type_1.UnionType) {
             return replaceUnion(t, builder, forwardingRef, transformedTypes, ctx.debugPrintTransformations);
         }
@@ -178,13 +179,13 @@ function makeTransformations(ctx, graph, targetLanguage) {
         if (t.kind === "string") {
             return replaceString(t, builder, forwardingRef, ctx.debugPrintTransformations);
         }
-        if (Type_1.isNumberTypeKind(t.kind)) {
+        if ((0, Type_1.isNumberTypeKind)(t.kind)) {
             return replaceNumber(t, builder, forwardingRef, ctx.debugPrintTransformations);
         }
-        if (Type_1.isPrimitiveStringTypeKind(t.kind)) {
+        if ((0, Type_1.isPrimitiveStringTypeKind)(t.kind)) {
             return replaceTransformedStringType(t, t.kind, builder, forwardingRef, ctx.debugPrintTransformations);
         }
-        return Support_1.panic(`Cannot make transformation for type ${t.kind}`);
+        return (0, Support_1.panic)(`Cannot make transformation for type ${t.kind}`);
     }
     const groups = Array.from(transformedTypes).map(t => [t]);
     return graph.rewrite("make-transformations", ctx.stringTypeMapping, false, groups, ctx.debugPrintReconstitution, replace);

package/dist/quicktype-core/MarkovChain.d.ts

@@ -1,9 +1,9 @@
-export declare type SubTrie = number | null | Trie;
-export declare type Trie = {
+export type SubTrie = number | null | Trie;
+export type Trie = {
     count: number;
     arr: SubTrie[];
 };
-export declare type MarkovChain = {
+export type MarkovChain = {
     trie: Trie;
     depth: number;
 };

package/dist/quicktype-core/MarkovChain.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = exports.generate = exports.evaluate = exports.evaluateFull = exports.load = exports.train = void 0;
 const Support_1 = require("./support/Support");
 const EncodedMarkovChain_1 = require("./EncodedMarkovChain");
 function makeTrie() {
@@ -35,14 +36,14 @@ function increment(t, seq, i) {
     }
     if (i >= seq.length - 1) {
         if (typeof t !== "object") {
-            return Support_1.panic("Malformed trie");
+            return (0, Support_1.panic)("Malformed trie");
         }
         let n = t.arr[first];
         if (n === null) {
             n = 0;
         }
         else if (typeof n === "object") {
-            return Support_1.panic("Malformed trie");
+            return (0, Support_1.panic)("Malformed trie");
         }
         t.arr[first] = n + 1;
         t.count += 1;
@@ -53,7 +54,7 @@ function increment(t, seq, i) {
         t.arr[first] = st = makeTrie();
     }
     if (typeof st !== "object") {
-        return Support_1.panic("Malformed trie");
+        return (0, Support_1.panic)("Malformed trie");
     }
     return increment(st, seq, i + 1);
 }
@@ -68,7 +69,7 @@ function train(lines, depth) {
 }
 exports.train = train;
 function load() {
-    return JSON.parse(Support_1.inflateBase64(EncodedMarkovChain_1.encodedMarkovChain));
+    return JSON.parse((0, Support_1.inflateBase64)(EncodedMarkovChain_1.encodedMarkovChain));
 }
 exports.load = load;
 function evaluateFull(mc, word) {
@@ -81,7 +82,7 @@ function evaluateFull(mc, word) {
     for (let i = depth; i <= word.length; i++) {
         let cp = lookup(trie, word.slice(i - depth, i), 0);
         if (typeof cp === "object") {
-            return Support_1.panic("Did we mess up the depth?");
+            return (0, Support_1.panic)("Did we mess up the depth?");
         }
         if (cp === undefined) {
             cp = 0.0001;
@@ -101,10 +102,10 @@ function randomInt(lower, upper) {
     return lower + Math.floor(Math.random() * range);
 }
 function generate(mc, state, unseenWeight) {
-    Support_1.assert(state.length === mc.depth - 1, "State and chain length don't match up");
+    (0, Support_1.assert)(state.length === mc.depth - 1, "State and chain length don't match up");
     const t = lookup(mc.trie, state, 0);
     if (typeof t === "number") {
-        return Support_1.panic("Wrong depth?");
+        return (0, Support_1.panic)("Wrong depth?");
     }
     if (t === undefined) {
         return String.fromCharCode(randomInt(32, 127));
@@ -122,7 +123,7 @@ function generate(mc, state, unseenWeight) {
             return String.fromCharCode(i);
         }
     }
-    return Support_1.panic("We screwed up bookkeeping, or randomInt");
+    return (0, Support_1.panic)("We screwed up bookkeeping, or randomInt");
 }
 exports.generate = generate;
 function testWord(mc, word) {

package/dist/quicktype-core/Messages.d.ts

@@ -1,6 +1,6 @@
 import { StringMap } from "./support/Support";
 import { Ref } from "./input/JSONSchemaInput";
-export declare type ErrorProperties = {
+export type ErrorProperties = {
     kind: "InternalError";
     properties: {
         message: string;
@@ -276,10 +276,10 @@ export declare type ErrorProperties = {
         message: string;
     };
 };
-export declare type ErrorKinds = ErrorProperties extends {
+export type ErrorKinds = ErrorProperties extends {
     kind: infer K;
 } ? K : never;
-export declare type ErrorPropertiesForName<K> = Extract<ErrorProperties, {
+export type ErrorPropertiesForName<K> = Extract<ErrorProperties, {
     kind: K;
 }> extends {
     properties: infer P;