quicktype 17.0.1 → 17.0.3

package/dist/quicktype-core/rewrites/FlattenStrings.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenStrings = void 0;
 const collection_utils_1 = require("collection-utils");
 const TypeUtils_1 = require("../TypeUtils");
 const Support_1 = require("../support/Support");
@@ -13,15 +14,15 @@ function unionNeedsReplacing(u) {
     const stringType = u.findMember("string");
     if (stringType === undefined)
         return undefined;
-    Support_1.assert(!TypeUtils_1.stringTypesForType(stringType).isRestricted, "We must only flatten strings if we have no restriced strings");
+    (0, Support_1.assert)(!(0, TypeUtils_1.stringTypesForType)(stringType).isRestricted, "We must only flatten strings if we have no restriced strings");
     return stringMembers;
 }
 // Replaces all string types in an enum with the basic string type.
 function replaceUnion(group, builder, forwardingRef) {
-    Support_1.assert(group.size === 1);
-    const u = Support_1.defined(collection_utils_1.iterableFirst(group));
-    const stringMembers = Support_1.defined(unionNeedsReplacing(u));
-    const stringAttributes = TypeUtils_1.combineTypeAttributesOfTypes("union", stringMembers);
+    (0, Support_1.assert)(group.size === 1);
+    const u = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(group));
+    const stringMembers = (0, Support_1.defined)(unionNeedsReplacing(u));
+    const stringAttributes = (0, TypeUtils_1.combineTypeAttributesOfTypes)("union", stringMembers);
     const types = [];
     for (const t of u.members) {
         if (stringMembers.has(t))
@@ -29,7 +30,7 @@ function replaceUnion(group, builder, forwardingRef) {
         types.push(builder.reconstituteType(t));
     }
     if (types.length === 0) {
-        return builder.getStringType(TypeAttributes_1.combineTypeAttributes("union", stringAttributes, u.getAttributes()), undefined, forwardingRef);
+        return builder.getStringType((0, TypeAttributes_1.combineTypeAttributes)("union", stringAttributes, u.getAttributes()), undefined, forwardingRef);
     }
     types.push(builder.getStringType(stringAttributes, undefined));
     return builder.getUnionType(u.getAttributes(), new Set(types), forwardingRef);

package/dist/quicktype-core/rewrites/FlattenUnions.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenUnions = void 0;
 const collection_utils_1 = require("collection-utils");
 const TypeGraph_1 = require("../TypeGraph");
 const Type_1 = require("../Type");
@@ -12,22 +13,22 @@ function flattenUnions(graph, stringTypeMapping, conflateNumbers, makeObjectType
     let needsRepeat = false;
     function replace(types, builder, forwardingRef) {
         const unionBuilder = new UnifyClasses_1.UnifyUnionBuilder(builder, makeObjectTypes, true, trefs => {
-            Support_1.assert(trefs.length > 0, "Must have at least one type to build union");
-            trefs = trefs.map(tref => builder.reconstituteType(TypeGraph_1.derefTypeRef(tref, graph)));
+            (0, Support_1.assert)(trefs.length > 0, "Must have at least one type to build union");
+            trefs = trefs.map(tref => builder.reconstituteType((0, TypeGraph_1.derefTypeRef)(tref, graph)));
             if (trefs.length === 1) {
                 return trefs[0];
             }
             needsRepeat = true;
             return builder.getUnionType(TypeAttributes_1.emptyTypeAttributes, new Set(trefs));
         });
-        return UnifyClasses_1.unifyTypes(types, TypeAttributes_1.emptyTypeAttributes, builder, unionBuilder, conflateNumbers, forwardingRef);
+        return (0, UnifyClasses_1.unifyTypes)(types, TypeAttributes_1.emptyTypeAttributes, builder, unionBuilder, conflateNumbers, forwardingRef);
     }
-    const allUnions = collection_utils_1.setFilter(graph.allTypesUnordered(), t => t instanceof Type_1.UnionType);
-    const nonCanonicalUnions = collection_utils_1.setFilter(allUnions, u => !u.isCanonical);
+    const allUnions = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), t => t instanceof Type_1.UnionType);
+    const nonCanonicalUnions = (0, collection_utils_1.setFilter)(allUnions, u => !u.isCanonical);
     let foundIntersection = false;
-    const groups = TypeUtils_1.makeGroupsToFlatten(nonCanonicalUnions, members => {
-        Messages_1.messageAssert(members.size > 0, "IRNoEmptyUnions", {});
-        if (!collection_utils_1.iterableSome(members, m => m instanceof Type_1.IntersectionType))
+    const groups = (0, TypeUtils_1.makeGroupsToFlatten)(nonCanonicalUnions, members => {
+        (0, Messages_1.messageAssert)(members.size > 0, "IRNoEmptyUnions", {});
+        if (!(0, collection_utils_1.iterableSome)(members, m => m instanceof Type_1.IntersectionType))
             return true;
         // FIXME: This is stupid.  `flattenUnions` returns true when no more union
         // flattening is necessary, but `resolveIntersections` can introduce new

package/dist/quicktype-core/rewrites/InferMaps.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferMaps = void 0;
 const collection_utils_1 = require("collection-utils");
 const Type_1 = require("../Type");
 const TypeUtils_1 = require("../TypeUtils");
@@ -11,9 +12,9 @@ const stringMapSizeThreshold = 50;
 let markovChain = undefined;
 function nameProbability(name) {
     if (markovChain === undefined) {
-        markovChain = MarkovChain_1.load();
+        markovChain = (0, MarkovChain_1.load)();
     }
-    return MarkovChain_1.evaluate(markovChain, name);
+    return (0, MarkovChain_1.evaluate)(markovChain, name);
 }
 function shouldBeMap(properties) {
     // Only classes with a certain number of properties are inferred
@@ -23,13 +24,13 @@ function shouldBeMap(properties) {
         return undefined;
     // If all property names are digit-only, we always make a map, no
     // questions asked.
-    if (collection_utils_1.iterableEvery(properties.keys(), n => /^[0-9]+$/.test(n))) {
-        return collection_utils_1.setMap(properties.values(), cp => cp.type);
+    if ((0, collection_utils_1.iterableEvery)(properties.keys(), n => /^[0-9]+$/.test(n))) {
+        return (0, collection_utils_1.setMap)(properties.values(), cp => cp.type);
     }
     // If all properties are strings or null then an object must have at least
     // `stringMapSizeThreshold` to qualify as a map.
     if (numProperties < stringMapSizeThreshold &&
-        collection_utils_1.iterableEvery(properties.values(), cp => Type_1.isPrimitiveStringTypeKind(cp.type.kind) || cp.type.kind === "null")) {
+        (0, collection_utils_1.iterableEvery)(properties.values(), cp => (0, Type_1.isPrimitiveStringTypeKind)(cp.type.kind) || cp.type.kind === "null")) {
         return undefined;
     }
     if (numProperties < mapSizeThreshold) {
@@ -69,12 +70,12 @@ function shouldBeMap(properties) {
     // Check that all the property types are the same, modulo nullability.
     for (const [, p] of properties) {
         // The set of types first property can be, minus null.
-        const nn = TypeUtils_1.removeNullFromType(p.type)[1];
+        const nn = (0, TypeUtils_1.removeNullFromType)(p.type)[1];
         if (nn.size > 0) {
             if (firstNonNullCases !== undefined) {
                 // The set of non-null cases for all other properties must
                 // be the the same, otherwise we won't infer a map.
-                if (!Type_1.setOperationCasesEqual(nn, firstNonNullCases, true, (a, b) => a.structurallyCompatible(b, true))) {
+                if (!(0, Type_1.setOperationCasesEqual)(nn, firstNonNullCases, true, (a, b) => a.structurallyCompatible(b, true))) {
                     canBeMap = false;
                     break;
                 }
@@ -92,11 +93,11 @@ function shouldBeMap(properties) {
 }
 function inferMaps(graph, stringTypeMapping, conflateNumbers, debugPrintReconstitution) {
     function replaceClass(setOfOneClass, builder, forwardingRef) {
-        const c = Support_1.defined(collection_utils_1.iterableFirst(setOfOneClass));
+        const c = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(setOfOneClass));
         const properties = c.getProperties();
         const shouldBe = shouldBeMap(properties);
         if (shouldBe === undefined) {
-            return Support_1.panic(`We shouldn't be replacing class ${c.getCombinedName()} with a map`);
+            return (0, Support_1.panic)(`We shouldn't be replacing class ${c.getCombinedName()} with a map`);
         }
         // Now reconstitute all the types in the new graph.  TypeGraphs are
         // immutable, so any change in the graph actually means building a new
@@ -104,7 +105,7 @@ function inferMaps(graph, stringTypeMapping, conflateNumbers, debugPrintReconsti
         // Reconstituting a type means generating the "same" type in the new
         // type graph.  Except we don't get Type objects but TypeRef objects,
         // which is a type-to-be.
-        return builder.getMapType(c.getAttributes(), UnifyClasses_1.unifyTypes(shouldBe, c.getAttributes(), builder, UnifyClasses_1.unionBuilderForUnification(builder, false, false, conflateNumbers), conflateNumbers), forwardingRef);
+        return builder.getMapType(c.getAttributes(), (0, UnifyClasses_1.unifyTypes)(shouldBe, c.getAttributes(), builder, (0, UnifyClasses_1.unionBuilderForUnification)(builder, false, false, conflateNumbers), conflateNumbers), forwardingRef);
     }
     const classesToReplace = Array.from(graph.allNamedTypesSeparated().objects).filter(o => {
         if (!(o instanceof Type_1.ClassType))

package/dist/quicktype-core/rewrites/ReplaceObjectType.js

@@ -1,22 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceObjectType = void 0;
 const collection_utils_1 = require("collection-utils");
 const Support_1 = require("../support/Support");
 const TypeAttributes_1 = require("../attributes/TypeAttributes");
 function replaceObjectType(graph, stringTypeMapping, _conflateNumbers, leaveFullObjects, debugPrintReconstitution) {
     function replace(setOfOneType, builder, forwardingRef) {
-        const o = Support_1.defined(collection_utils_1.iterableFirst(setOfOneType));
+        const o = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(setOfOneType));
         const attributes = o.getAttributes();
         const properties = o.getProperties();
         const additionalProperties = o.getAdditionalProperties();
         function reconstituteProperties() {
-            return collection_utils_1.mapMap(properties, cp => builder.makeClassProperty(builder.reconstituteTypeRef(cp.typeRef), cp.isOptional));
+            return (0, collection_utils_1.mapMap)(properties, cp => builder.makeClassProperty(builder.reconstituteTypeRef(cp.typeRef), cp.isOptional));
         }
         function makeClass() {
             return builder.getUniqueClassType(attributes, true, reconstituteProperties(), forwardingRef);
         }
         function reconstituteAdditionalProperties() {
-            return builder.reconstituteType(Support_1.defined(additionalProperties));
+            return builder.reconstituteType((0, Support_1.defined)(additionalProperties));
         }
         if (additionalProperties === undefined) {
             return makeClass();
@@ -30,10 +31,10 @@ function replaceObjectType(graph, stringTypeMapping, _conflateNumbers, leaveFull
             return makeClass();
         }
         // FIXME: Warn that we're losing class semantics.
-        const propertyTypes = collection_utils_1.setMap(properties.values(), cp => cp.type).add(additionalProperties);
+        const propertyTypes = (0, collection_utils_1.setMap)(properties.values(), cp => cp.type).add(additionalProperties);
         let union = builder.lookupTypeRefs(Array.from(propertyTypes).map(t => t.typeRef));
         if (union === undefined) {
-            const reconstitutedTypes = collection_utils_1.setMap(propertyTypes, t => builder.reconstituteType(t));
+            const reconstitutedTypes = (0, collection_utils_1.setMap)(propertyTypes, t => builder.reconstituteType(t));
             union = builder.getUniqueUnionType(TypeAttributes_1.emptyTypeAttributes, new Set(reconstitutedTypes));
             // This is the direct unification alternative.  Weirdly enough, it is a tiny
             // bit slower.  It gives the same results.
@@ -49,9 +50,9 @@ function replaceObjectType(graph, stringTypeMapping, _conflateNumbers, leaveFull
         }
         return builder.getMapType(attributes, union, forwardingRef);
     }
-    const allObjectTypes = collection_utils_1.setFilter(graph.allTypesUnordered(), t => t.kind === "object");
+    const allObjectTypes = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), t => t.kind === "object");
     const objectTypesToReplace = leaveFullObjects
-        ? collection_utils_1.setFilter(allObjectTypes, o => o.getProperties().size === 0 || o.getAdditionalProperties() === undefined)
+        ? (0, collection_utils_1.setFilter)(allObjectTypes, o => o.getProperties().size === 0 || o.getAdditionalProperties() === undefined)
         : allObjectTypes;
     const groups = Array.from(objectTypesToReplace).map(t => [t]);
     return graph.rewrite("replace object type", stringTypeMapping, false, groups, debugPrintReconstitution, replace);

package/dist/quicktype-core/rewrites/ResolveIntersections.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveIntersections = void 0;
 const collection_utils_1 = require("collection-utils");
 const UnionBuilder_1 = require("../UnionBuilder");
 const Type_1 = require("../Type");
@@ -7,56 +8,59 @@ const TypeUtils_1 = require("../TypeUtils");
 const Support_1 = require("../support/Support");
 const TypeAttributes_1 = require("../attributes/TypeAttributes");
 function canResolve(t) {
-    const members = TypeUtils_1.setOperationMembersRecursively(t, undefined)[0];
+    const members = (0, TypeUtils_1.setOperationMembersRecursively)(t, undefined)[0];
     if (members.size <= 1)
         return true;
-    return collection_utils_1.iterableEvery(members, m => !(m instanceof Type_1.UnionType) || m.isCanonical);
+    return (0, collection_utils_1.iterableEvery)(members, m => !(m instanceof Type_1.UnionType) || m.isCanonical);
 }
 function attributesForTypes(types) {
-    return collection_utils_1.mapMapEntries(types.entries(), t => [t.kind, t.getAttributes()]);
+    return (0, collection_utils_1.mapMapEntries)(types.entries(), t => [t.kind, t.getAttributes()]);
 }
 class IntersectionAccumulator {
-    constructor() {
-        this._primitiveAttributes = new Map();
-        this._arrayAttributes = TypeAttributes_1.emptyTypeAttributes;
-        // We start out with all object types allowed, which means
-        // _additionalPropertyTypes is empty - no restrictions - and
-        // _classProperties is empty - no defined properties so far.
-        //
-        // If _additionalPropertyTypes is undefined, no additional
-        // properties are allowed anymore.  If _classProperties is
-        // undefined, no object types are allowed, in which case
-        // _additionalPropertyTypes must also be undefined;
-        this._objectProperties = new Map();
-        this._objectAttributes = TypeAttributes_1.emptyTypeAttributes;
-        this._additionalPropertyTypes = new Set();
-        this._lostTypeAttributes = false;
-    }
+    _primitiveTypes;
+    _primitiveAttributes = new Map();
+    // * undefined: We haven't seen any types yet.
+    // * Set: All types we've seen can be arrays.
+    // * false: At least one of the types seen can't be an array.
+    _arrayItemTypes;
+    _arrayAttributes = TypeAttributes_1.emptyTypeAttributes;
+    // We start out with all object types allowed, which means
+    // _additionalPropertyTypes is empty - no restrictions - and
+    // _classProperties is empty - no defined properties so far.
+    //
+    // If _additionalPropertyTypes is undefined, no additional
+    // properties are allowed anymore.  If _classProperties is
+    // undefined, no object types are allowed, in which case
+    // _additionalPropertyTypes must also be undefined;
+    _objectProperties = new Map();
+    _objectAttributes = TypeAttributes_1.emptyTypeAttributes;
+    _additionalPropertyTypes = new Set();
+    _lostTypeAttributes = false;
     updatePrimitiveTypes(members) {
-        const types = collection_utils_1.setFilter(members, t => Type_1.isPrimitiveTypeKind(t.kind));
+        const types = (0, collection_utils_1.setFilter)(members, t => (0, Type_1.isPrimitiveTypeKind)(t.kind));
         const attributes = attributesForTypes(types);
-        collection_utils_1.mapMergeWithInto(this._primitiveAttributes, (a, b) => TypeAttributes_1.combineTypeAttributes("intersect", a, b), attributes);
-        const kinds = collection_utils_1.setMap(types, t => t.kind);
+        (0, collection_utils_1.mapMergeWithInto)(this._primitiveAttributes, (a, b) => (0, TypeAttributes_1.combineTypeAttributes)("intersect", a, b), attributes);
+        const kinds = (0, collection_utils_1.setMap)(types, t => t.kind);
         if (this._primitiveTypes === undefined) {
             this._primitiveTypes = new Set(kinds);
             return;
         }
-        const haveNumber = collection_utils_1.iterableFind(this._primitiveTypes, Type_1.isNumberTypeKind) !== undefined &&
-            collection_utils_1.iterableFind(kinds, Type_1.isNumberTypeKind) !== undefined;
-        this._primitiveTypes = collection_utils_1.setIntersect(this._primitiveTypes, kinds);
-        if (haveNumber && collection_utils_1.iterableFind(this._primitiveTypes, Type_1.isNumberTypeKind) === undefined) {
+        const haveNumber = (0, collection_utils_1.iterableFind)(this._primitiveTypes, Type_1.isNumberTypeKind) !== undefined &&
+            (0, collection_utils_1.iterableFind)(kinds, Type_1.isNumberTypeKind) !== undefined;
+        this._primitiveTypes = (0, collection_utils_1.setIntersect)(this._primitiveTypes, kinds);
+        if (haveNumber && (0, collection_utils_1.iterableFind)(this._primitiveTypes, Type_1.isNumberTypeKind) === undefined) {
             // One set has integer, the other has double.  The intersection
             // of that is integer.
             this._primitiveTypes = this._primitiveTypes.add("integer");
         }
     }
     updateArrayItemTypes(members) {
-        const maybeArray = collection_utils_1.iterableFind(members, t => t instanceof Type_1.ArrayType);
+        const maybeArray = (0, collection_utils_1.iterableFind)(members, t => t instanceof Type_1.ArrayType);
         if (maybeArray === undefined) {
             this._arrayItemTypes = false;
             return;
         }
-        this._arrayAttributes = TypeAttributes_1.combineTypeAttributes("intersect", this._arrayAttributes, maybeArray.getAttributes());
+        this._arrayAttributes = (0, TypeAttributes_1.combineTypeAttributes)("intersect", this._arrayAttributes, maybeArray.getAttributes());
         if (this._arrayItemTypes === undefined) {
             this._arrayItemTypes = new Set();
         }
@@ -65,43 +69,43 @@ class IntersectionAccumulator {
         }
     }
     updateObjectProperties(members) {
-        const maybeObject = collection_utils_1.iterableFind(members, t => t instanceof Type_1.ObjectType);
+        const maybeObject = (0, collection_utils_1.iterableFind)(members, t => t instanceof Type_1.ObjectType);
         if (maybeObject === undefined) {
             this._objectProperties = undefined;
             this._additionalPropertyTypes = undefined;
             return;
         }
-        this._objectAttributes = TypeAttributes_1.combineTypeAttributes("intersect", this._objectAttributes, maybeObject.getAttributes());
+        this._objectAttributes = (0, TypeAttributes_1.combineTypeAttributes)("intersect", this._objectAttributes, maybeObject.getAttributes());
         const objectAdditionalProperties = maybeObject.getAdditionalProperties();
         if (this._objectProperties === undefined) {
-            Support_1.assert(this._additionalPropertyTypes === undefined);
+            (0, Support_1.assert)(this._additionalPropertyTypes === undefined);
             return;
         }
-        const allPropertyNames = collection_utils_1.setUnionInto(new Set(this._objectProperties.keys()), maybeObject.getProperties().keys());
+        const allPropertyNames = (0, collection_utils_1.setUnionInto)(new Set(this._objectProperties.keys()), maybeObject.getProperties().keys());
         for (const name of allPropertyNames) {
-            const existing = Support_1.defined(this._objectProperties).get(name);
+            const existing = (0, Support_1.defined)(this._objectProperties).get(name);
             const newProperty = maybeObject.getProperties().get(name);
             if (existing !== undefined && newProperty !== undefined) {
                 const cp = new Type_1.GenericClassProperty(existing.typeData.add(newProperty.type), existing.isOptional && newProperty.isOptional);
-                Support_1.defined(this._objectProperties).set(name, cp);
+                (0, Support_1.defined)(this._objectProperties).set(name, cp);
             }
             else if (existing !== undefined && objectAdditionalProperties !== undefined) {
                 const cp = new Type_1.GenericClassProperty(existing.typeData.add(objectAdditionalProperties), existing.isOptional);
-                Support_1.defined(this._objectProperties).set(name, cp);
+                (0, Support_1.defined)(this._objectProperties).set(name, cp);
             }
             else if (existing !== undefined) {
-                Support_1.defined(this._objectProperties).delete(name);
+                (0, Support_1.defined)(this._objectProperties).delete(name);
             }
             else if (newProperty !== undefined && this._additionalPropertyTypes !== undefined) {
                 // FIXME: This is potentially slow
                 const types = new Set(this._additionalPropertyTypes).add(newProperty.type);
-                Support_1.defined(this._objectProperties).set(name, new Type_1.GenericClassProperty(types, newProperty.isOptional));
+                (0, Support_1.defined)(this._objectProperties).set(name, new Type_1.GenericClassProperty(types, newProperty.isOptional));
             }
             else if (newProperty !== undefined) {
-                Support_1.defined(this._objectProperties).delete(name);
+                (0, Support_1.defined)(this._objectProperties).delete(name);
             }
             else {
-                return Support_1.mustNotHappen();
+                return (0, Support_1.mustNotHappen)();
             }
         }
         if (this._additionalPropertyTypes !== undefined && objectAdditionalProperties !== undefined) {
@@ -119,40 +123,40 @@ class IntersectionAccumulator {
     }
     addType(t) {
         let attributes = t.getAttributes();
-        TypeUtils_1.matchTypeExhaustive(t, _noneType => {
-            return Support_1.panic("There shouldn't be a none type");
+        (0, TypeUtils_1.matchTypeExhaustive)(t, _noneType => {
+            return (0, Support_1.panic)("There shouldn't be a none type");
         }, _anyType => {
-            return Support_1.panic("The any type should have been filtered out in setOperationMembersRecursively");
-        }, nullType => this.addUnionSet([nullType]), boolType => this.addUnionSet([boolType]), integerType => this.addUnionSet([integerType]), doubleType => this.addUnionSet([doubleType]), stringType => this.addUnionSet([stringType]), arrayType => this.addUnionSet([arrayType]), _classType => Support_1.panic("We should never see class types in intersections"), _mapType => Support_1.panic("We should never see map types in intersections"), objectType => this.addUnionSet([objectType]), _enumType => Support_1.panic("We should never see enum types in intersections"), unionType => {
-            attributes = TypeAttributes_1.combineTypeAttributes("intersect", [attributes].concat(Array.from(unionType.members).map(m => m.getAttributes())));
+            return (0, Support_1.panic)("The any type should have been filtered out in setOperationMembersRecursively");
+        }, nullType => this.addUnionSet([nullType]), boolType => this.addUnionSet([boolType]), integerType => this.addUnionSet([integerType]), doubleType => this.addUnionSet([doubleType]), stringType => this.addUnionSet([stringType]), arrayType => this.addUnionSet([arrayType]), _classType => (0, Support_1.panic)("We should never see class types in intersections"), _mapType => (0, Support_1.panic)("We should never see map types in intersections"), objectType => this.addUnionSet([objectType]), _enumType => (0, Support_1.panic)("We should never see enum types in intersections"), unionType => {
+            attributes = (0, TypeAttributes_1.combineTypeAttributes)("intersect", [attributes].concat(Array.from(unionType.members).map(m => m.getAttributes())));
             this.addUnionSet(unionType.members);
         }, transformedStringType => this.addUnionSet([transformedStringType]));
-        return TypeAttributes_1.makeTypeAttributesInferred(attributes);
+        return (0, TypeAttributes_1.makeTypeAttributesInferred)(attributes);
     }
     get arrayData() {
         if (this._arrayItemTypes === undefined || this._arrayItemTypes === false) {
-            return Support_1.panic("This should not be called if the type can't be an array");
+            return (0, Support_1.panic)("This should not be called if the type can't be an array");
         }
         return this._arrayItemTypes;
     }
     get objectData() {
         if (this._objectProperties === undefined) {
-            Support_1.assert(this._additionalPropertyTypes === undefined);
+            (0, Support_1.assert)(this._additionalPropertyTypes === undefined);
             return undefined;
         }
         return [this._objectProperties, this._additionalPropertyTypes];
     }
     get enumCases() {
-        return Support_1.panic("We don't support enums in intersections");
+        return (0, Support_1.panic)("We don't support enums in intersections");
     }
     getMemberKinds() {
-        const kinds = collection_utils_1.mapMap(Support_1.defined(this._primitiveTypes).entries(), k => Support_1.defined(this._primitiveAttributes.get(k)));
+        const kinds = (0, collection_utils_1.mapMap)((0, Support_1.defined)(this._primitiveTypes).entries(), k => (0, Support_1.defined)(this._primitiveAttributes.get(k)));
         const maybeDoubleAttributes = this._primitiveAttributes.get("double");
         // If double was eliminated, add its attributes to integer
         if (maybeDoubleAttributes !== undefined && !kinds.has("double") && kinds.has("integer")) {
             // FIXME: How can this ever happen???  Where do we "eliminate" double?
-            collection_utils_1.mapUpdateInto(kinds, "integer", a => {
-                return TypeAttributes_1.combineTypeAttributes("intersect", Support_1.defined(a), maybeDoubleAttributes);
+            (0, collection_utils_1.mapUpdateInto)(kinds, "integer", a => {
+                return (0, TypeAttributes_1.combineTypeAttributes)("intersect", (0, Support_1.defined)(a), maybeDoubleAttributes);
             });
         }
         if (this._arrayItemTypes !== undefined && this._arrayItemTypes !== false) {
@@ -174,13 +178,10 @@ class IntersectionAccumulator {
     }
 }
 class IntersectionUnionBuilder extends UnionBuilder_1.UnionBuilder {
-    constructor() {
-        super(...arguments);
-        this._createdNewIntersections = false;
-    }
+    _createdNewIntersections = false;
     makeIntersection(members, attributes) {
-        const reconstitutedMembers = collection_utils_1.setMap(members, t => this.typeBuilder.reconstituteTypeRef(t.typeRef));
-        const first = Support_1.defined(collection_utils_1.iterableFirst(reconstitutedMembers));
+        const reconstitutedMembers = (0, collection_utils_1.setMap)(members, t => this.typeBuilder.reconstituteTypeRef(t.typeRef));
+        const first = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(reconstitutedMembers));
         if (reconstitutedMembers.size === 1) {
             this.typeBuilder.addAttributes(first, attributes);
             return first;
@@ -193,10 +194,10 @@ class IntersectionUnionBuilder extends UnionBuilder_1.UnionBuilder {
     }
     makeObject(maybeData, typeAttributes, forwardingRef) {
         if (maybeData === undefined) {
-            return Support_1.panic("Either properties or additional properties must be given to make an object type");
+            return (0, Support_1.panic)("Either properties or additional properties must be given to make an object type");
         }
         const [propertyTypes, maybeAdditionalProperties] = maybeData;
-        const properties = collection_utils_1.mapMap(propertyTypes, cp => this.typeBuilder.makeClassProperty(this.makeIntersection(cp.typeData, TypeAttributes_1.emptyTypeAttributes), cp.isOptional));
+        const properties = (0, collection_utils_1.mapMap)(propertyTypes, cp => this.typeBuilder.makeClassProperty(this.makeIntersection(cp.typeData, TypeAttributes_1.emptyTypeAttributes), cp.isOptional));
         const additionalProperties = maybeAdditionalProperties === undefined
             ? undefined
             : this.makeIntersection(maybeAdditionalProperties, TypeAttributes_1.emptyTypeAttributes);
@@ -212,18 +213,18 @@ class IntersectionUnionBuilder extends UnionBuilder_1.UnionBuilder {
 function resolveIntersections(graph, stringTypeMapping, debugPrintReconstitution) {
     let needsRepeat = false;
     function replace(types, builder, forwardingRef) {
-        const intersections = collection_utils_1.setFilter(types, t => t instanceof Type_1.IntersectionType);
-        const [members, intersectionAttributes] = TypeUtils_1.setOperationMembersRecursively(Array.from(intersections), "intersect");
+        const intersections = (0, collection_utils_1.setFilter)(types, t => t instanceof Type_1.IntersectionType);
+        const [members, intersectionAttributes] = (0, TypeUtils_1.setOperationMembersRecursively)(Array.from(intersections), "intersect");
         if (members.size === 0) {
             const t = builder.getPrimitiveType("any", intersectionAttributes, forwardingRef);
             return t;
         }
         if (members.size === 1) {
-            return builder.reconstituteType(Support_1.defined(collection_utils_1.iterableFirst(members)), intersectionAttributes, forwardingRef);
+            return builder.reconstituteType((0, Support_1.defined)((0, collection_utils_1.iterableFirst)(members)), intersectionAttributes, forwardingRef);
         }
         const accumulator = new IntersectionAccumulator();
-        const extraAttributes = TypeAttributes_1.makeTypeAttributesInferred(TypeAttributes_1.combineTypeAttributes("intersect", Array.from(members).map(t => accumulator.addType(t))));
-        const attributes = TypeAttributes_1.combineTypeAttributes("intersect", intersectionAttributes, extraAttributes);
+        const extraAttributes = (0, TypeAttributes_1.makeTypeAttributesInferred)((0, TypeAttributes_1.combineTypeAttributes)("intersect", Array.from(members).map(t => accumulator.addType(t))));
+        const attributes = (0, TypeAttributes_1.combineTypeAttributes)("intersect", intersectionAttributes, extraAttributes);
         const unionBuilder = new IntersectionUnionBuilder(builder);
         const tref = unionBuilder.buildUnion(accumulator, true, attributes, forwardingRef);
         if (unionBuilder.createdNewIntersections) {
@@ -233,9 +234,9 @@ function resolveIntersections(graph, stringTypeMapping, debugPrintReconstitution
     }
     // FIXME: We need to handle intersections that resolve to the same set of types.
     // See for example the intersections-nested.schema example.
-    const allIntersections = collection_utils_1.setFilter(graph.allTypesUnordered(), t => t instanceof Type_1.IntersectionType);
-    const resolvableIntersections = collection_utils_1.setFilter(allIntersections, canResolve);
-    const groups = TypeUtils_1.makeGroupsToFlatten(resolvableIntersections, undefined);
+    const allIntersections = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), t => t instanceof Type_1.IntersectionType);
+    const resolvableIntersections = (0, collection_utils_1.setFilter)(allIntersections, canResolve);
+    const groups = (0, TypeUtils_1.makeGroupsToFlatten)(resolvableIntersections, undefined);
     graph = graph.rewrite("resolve intersections", stringTypeMapping, false, groups, debugPrintReconstitution, replace);
     // console.log(`resolved ${resolvableIntersections.size} of ${intersections.size} intersections`);
     return [graph, !needsRepeat && allIntersections.size === resolvableIntersections.size];

package/dist/quicktype-core/support/Acronyms.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.acronymStyle = exports.acronymOption = exports.AcronymStyleOptions = exports.acronyms = void 0;
 const RendererOptions_1 = require("../RendererOptions");
 const Strings_1 = require("./Strings");
 exports.acronyms = [
@@ -1106,7 +1107,7 @@ var AcronymStyleOptions;
     AcronymStyleOptions["Original"] = "original";
     AcronymStyleOptions["Lower"] = "lowerCase";
 })(AcronymStyleOptions = exports.AcronymStyleOptions || (exports.AcronymStyleOptions = {}));
-exports.acronymOption = function (defaultOption) {
+const acronymOption = function (defaultOption) {
     return new RendererOptions_1.EnumOption("acronym-style", "Acronym naming style", [
         [AcronymStyleOptions.Original, AcronymStyleOptions.Original],
         [AcronymStyleOptions.Pascal, AcronymStyleOptions.Pascal],
@@ -1114,6 +1115,7 @@ exports.acronymOption = function (defaultOption) {
         [AcronymStyleOptions.Lower, AcronymStyleOptions.Lower]
     ], defaultOption, "secondary");
 };
+exports.acronymOption = acronymOption;
 function acronymStyle(style) {
     const options = {
         [AcronymStyleOptions.Pascal]: Strings_1.allUpperWordStyle,

package/dist/quicktype-core/support/Chance.js

@@ -34,7 +34,15 @@ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
 email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
 */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chance = void 0;
 class MersenneTwister {
+    N;
+    M;
+    MATRIX_A;
+    UPPER_MASK;
+    LOWER_MASK;
+    mt;
+    mti;
     constructor(seed) {
         if (seed === undefined) {
             // kept random number same size as time used previously to ensure no unexpected results downstream
@@ -105,6 +113,8 @@ class MersenneTwister {
 }
 // https://github.com/chancejs/chancejs
 class Chance {
+    seed;
+    mt;
     constructor(seed) {
         this.seed = seed;
         // If no generator function was provided, use our MT

package/dist/quicktype-core/support/Converters.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertersOption = exports.ConvertersOptions = void 0;
 const RendererOptions_1 = require("../RendererOptions");
 var ConvertersOptions;
 (function (ConvertersOptions) {

package/dist/quicktype-core/support/Strings.d.ts

@@ -1,5 +1,5 @@
-export declare type NamingStyle = "pascal" | "camel" | "underscore" | "upper-underscore" | "pascal-upper-acronyms" | "camel-upper-acronyms";
-declare type CodePointPredicate = (codePoint: number) => boolean;
+export type NamingStyle = "pascal" | "camel" | "underscore" | "upper-underscore" | "pascal-upper-acronyms" | "camel-upper-acronyms";
+type CodePointPredicate = (codePoint: number) => boolean;
 export declare function utf16ConcatMap(mapper: (utf16Unit: number) => string): (s: string) => string;
 export declare function utf32ConcatMap(mapper: (codePoint: number) => string): (s: string) => string;
 export declare function utf16LegalizeCharacters(isLegal: (utf16Unit: number) => boolean): (s: string) => string;
@@ -27,13 +27,13 @@ export declare function camelCase(str: string): string;
 export declare function snakeCase(str: string): string;
 export declare function startWithLetter(isAllowedStart: (codePoint: number) => boolean, // FIXME: technically, this operates on UTF16 units
 upper: boolean, str: string): string;
-export declare type WordInName = {
+export type WordInName = {
     word: string;
     isAcronym: boolean;
 };
 export declare const fastIsUpperCase: CodePointPredicate;
 export declare function splitIntoWords(s: string): WordInName[];
-export declare type WordStyle = (word: string) => string;
+export type WordStyle = (word: string) => string;
 export declare function firstUpperWordStyle(s: string): string;
 export declare function allUpperWordStyle(s: string): string;
 export declare function originalWord(s: string): string;