quicktype 17.0.1 → 17.0.2

package/dist/quicktype-core/attributes/Constraints.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.patternForType = exports.patternAttributeProducer = exports.patternTypeAttributeKind = exports.PatternTypeAttributeKind = exports.minMaxLengthForType = exports.minMaxValueForType = exports.minMaxLengthAttributeProducer = exports.minMaxAttributeProducer = exports.minMaxLengthTypeAttributeKind = exports.minMaxTypeAttributeKind = exports.MinMaxConstraintTypeAttributeKind = void 0;
 const TypeAttributes_1 = require("./TypeAttributes");
 const Support_1 = require("../support/Support");
 const Messages_1 = require("../Messages");
 function checkMinMaxConstraint(minmax) {
     const [min, max] = minmax;
     if (typeof min === "number" && typeof max === "number" && min > max) {
-        return Messages_1.messageError("MiscInvalidMinMaxConstraint", { min, max });
+        return (0, Messages_1.messageError)("MiscInvalidMinMaxConstraint", { min, max });
     }
     if (min === undefined && max === undefined) {
         return undefined;
@@ -14,6 +15,9 @@ function checkMinMaxConstraint(minmax) {
     return minmax;
 }
 class MinMaxConstraintTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
+    _typeKinds;
+    _minSchemaProperty;
+    _maxSchemaProperty;
     constructor(name, _typeKinds, _minSchemaProperty, _maxSchemaProperty) {
         super(name);
         this._typeKinds = _typeKinds;
@@ -24,7 +28,7 @@ class MinMaxConstraintTypeAttributeKind extends TypeAttributes_1.TypeAttributeKi
         return true;
     }
     combine(arr) {
-        Support_1.assert(arr.length > 0);
+        (0, Support_1.assert)(arr.length > 0);
         let [min, max] = arr[0];
         for (let i = 1; i < arr.length; i++) {
             const [otherMin, otherMax] = arr[i];
@@ -44,7 +48,7 @@ class MinMaxConstraintTypeAttributeKind extends TypeAttributes_1.TypeAttributeKi
         return checkMinMaxConstraint([min, max]);
     }
     intersect(arr) {
-        Support_1.assert(arr.length > 0);
+        (0, Support_1.assert)(arr.length > 0);
         let [min, max] = arr[0];
         for (let i = 1; i < arr.length; i++) {
             const [otherMin, otherMax] = arr[i];
@@ -133,7 +137,7 @@ class PatternTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
         return true;
     }
     combine(arr) {
-        Support_1.assert(arr.length > 0);
+        (0, Support_1.assert)(arr.length > 0);
         return arr.map(p => `(${p})`).join("|");
     }
     intersect(_arr) {

package/dist/quicktype-core/attributes/Description.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.descriptionAttributeProducer = exports.propertyDescriptionsTypeAttributeKind = exports.descriptionTypeAttributeKind = exports.addDescriptionToSchema = void 0;
 const collection_utils_1 = require("collection-utils");
 const TypeAttributes_1 = require("./TypeAttributes");
 const JSONSchemaInput_1 = require("../input/JSONSchemaInput");
@@ -14,7 +15,7 @@ class DescriptionTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
         super("description");
     }
     combine(attrs) {
-        return collection_utils_1.setUnionManyInto(new Set(), attrs);
+        return (0, collection_utils_1.setUnionManyInto)(new Set(), attrs);
     }
     makeInferred(_) {
         return undefined;
@@ -23,7 +24,7 @@ class DescriptionTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
         addDescriptionToSchema(schema, attrs);
     }
     stringify(descriptions) {
-        let result = collection_utils_1.iterableFirst(descriptions);
+        let result = (0, collection_utils_1.iterableFirst)(descriptions);
         if (result === undefined)
             return undefined;
         if (result.length > 5 + 3) {
@@ -44,7 +45,7 @@ class PropertyDescriptionsTypeAttributeKind extends TypeAttributes_1.TypeAttribu
         // FIXME: Implement this with mutable sets
         const result = new Map();
         for (const attr of attrs) {
-            collection_utils_1.mapMergeWithInto(result, (sa, sb) => collection_utils_1.setUnion(sa, sb), attr);
+            (0, collection_utils_1.mapMergeWithInto)(result, (sa, sb) => (0, collection_utils_1.setUnion)(sa, sb), attr);
         }
         return result;
     }
@@ -68,7 +69,7 @@ function descriptionAttributeProducer(schema, ref, types) {
     let propertyDescription = TypeAttributes_1.emptyTypeAttributes;
     const pathLength = ref.path.length;
     if (types.has("object") ||
-        collection_utils_1.setSubtract(types, ["null"]).size > 1 ||
+        (0, collection_utils_1.setSubtract)(types, ["null"]).size > 1 ||
         schema.enum !== undefined ||
         pathLength < 2 ||
         !isPropertiesKey(ref.path[pathLength - 2])) {
@@ -78,7 +79,7 @@ function descriptionAttributeProducer(schema, ref, types) {
         }
     }
     if (types.has("object") && typeof schema.properties === "object") {
-        const propertyDescriptions = collection_utils_1.mapFilterMap(collection_utils_1.mapFromObject(schema.properties), propSchema => {
+        const propertyDescriptions = (0, collection_utils_1.mapFilterMap)((0, collection_utils_1.mapFromObject)(schema.properties), propSchema => {
             if (typeof propSchema === "object") {
                 const desc = propSchema.description;
                 if (typeof desc === "string") {

package/dist/quicktype-core/attributes/EnumValues.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumValuesAttributeProducer = exports.enumCaseValues = exports.enumValuesTypeAttributeKind = void 0;
 const collection_utils_1 = require("collection-utils");
 const AccessorNames_1 = require("./AccessorNames");
 const TypeAttributes_1 = require("./TypeAttributes");
@@ -15,8 +16,8 @@ exports.enumValuesTypeAttributeKind = new EnumValuesTypeAttributeKind();
 function enumCaseValues(e, language) {
     const enumValues = exports.enumValuesTypeAttributeKind.tryGetInAttributes(e.getAttributes());
     if (enumValues === undefined)
-        return collection_utils_1.mapMap(e.cases.entries(), _ => undefined);
-    return collection_utils_1.mapMap(e.cases.entries(), c => AccessorNames_1.lookupKey(enumValues, c, language));
+        return (0, collection_utils_1.mapMap)(e.cases.entries(), _ => undefined);
+    return (0, collection_utils_1.mapMap)(e.cases.entries(), c => (0, AccessorNames_1.lookupKey)(enumValues, c, language));
 }
 exports.enumCaseValues = enumCaseValues;
 function enumValuesAttributeProducer(schema, _canonicalRef, _types) {
@@ -25,6 +26,6 @@ function enumValuesAttributeProducer(schema, _canonicalRef, _types) {
     const maybeEnumValues = schema["qt-enum-values"];
     if (maybeEnumValues === undefined)
         return undefined;
-    return { forType: exports.enumValuesTypeAttributeKind.makeAttributes(AccessorNames_1.makeAccessorNames(maybeEnumValues)) };
+    return { forType: exports.enumValuesTypeAttributeKind.makeAttributes((0, AccessorNames_1.makeAccessorNames)(maybeEnumValues)) };
 }
 exports.enumValuesAttributeProducer = enumValuesAttributeProducer;

package/dist/quicktype-core/attributes/StringTypes.d.ts

@@ -9,7 +9,7 @@ export declare class StringTypes {
     static fromCase(s: string, count: number): StringTypes;
     static fromCases(cases: string[]): StringTypes;
     constructor(cases: ReadonlyMap<string, number> | undefined, transformations: ReadonlySet<TransformedStringTypeKind>);
-    readonly isRestricted: boolean;
+    get isRestricted(): boolean;
     union(othersArray: StringTypes[], startIndex: number): StringTypes;
     intersect(othersArray: StringTypes[], startIndex: number): StringTypes;
     applyStringTypeMapping(mapping: StringTypeMapping): StringTypes;

package/dist/quicktype-core/attributes/StringTypes.js

@@ -1,18 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferTransformedStringTypeKindForString = exports.stringTypesTypeAttributeKind = exports.StringTypes = void 0;
 const collection_utils_1 = require("collection-utils");
 const TypeAttributes_1 = require("./TypeAttributes");
 const Support_1 = require("../support/Support");
 const TypeBuilder_1 = require("../TypeBuilder");
 class StringTypes {
-    // undefined means no restrictions
-    constructor(cases, transformations) {
-        this.cases = cases;
-        this.transformations = transformations;
-        if (cases === undefined) {
-            Support_1.assert(transformations.size === 0, "We can't have an unrestricted string that also allows transformations");
-        }
-    }
+    cases;
+    transformations;
+    static unrestricted = new StringTypes(undefined, new Set());
     static fromCase(s, count) {
         const caseMap = {};
         caseMap[s] = count;
@@ -25,6 +21,14 @@ class StringTypes {
         }
         return new StringTypes(new Map(cases.map(s => [s, 1])), new Set());
     }
+    // undefined means no restrictions
+    constructor(cases, transformations) {
+        this.cases = cases;
+        this.transformations = transformations;
+        if (cases === undefined) {
+            (0, Support_1.assert)(transformations.size === 0, "We can't have an unrestricted string that also allows transformations");
+        }
+    }
     get isRestricted() {
         return this.cases !== undefined;
     }
@@ -37,8 +41,8 @@ class StringTypes {
             const other = othersArray[i];
             if (other.cases === undefined)
                 return other;
-            collection_utils_1.mapMergeWithInto(cases, (x, y) => x + y, other.cases);
-            collection_utils_1.setUnionInto(transformations, other.transformations);
+            (0, collection_utils_1.mapMergeWithInto)(cases, (x, y) => x + y, other.cases);
+            (0, collection_utils_1.setUnionInto)(transformations, other.transformations);
         }
         return new StringTypes(cases, transformations);
     }
@@ -48,14 +52,14 @@ class StringTypes {
         for (let i = startIndex; i < othersArray.length; i++) {
             const other = othersArray[i];
             if (cases === undefined) {
-                cases = collection_utils_1.definedMap(other.cases, m => new Map(m));
+                cases = (0, collection_utils_1.definedMap)(other.cases, m => new Map(m));
             }
             else if (other.cases !== undefined) {
                 const thisCases = cases;
                 const otherCases = other.cases;
-                cases = collection_utils_1.mapMap(collection_utils_1.setIntersect(thisCases.keys(), new Set(otherCases.keys())).entries(), k => Math.min(Support_1.defined(thisCases.get(k)), Support_1.defined(otherCases.get(k))));
+                cases = (0, collection_utils_1.mapMap)((0, collection_utils_1.setIntersect)(thisCases.keys(), new Set(otherCases.keys())).entries(), k => Math.min((0, Support_1.defined)(thisCases.get(k)), (0, Support_1.defined)(otherCases.get(k))));
             }
-            transformations = collection_utils_1.setIntersect(transformations, other.transformations);
+            transformations = (0, collection_utils_1.setIntersect)(transformations, other.transformations);
         }
         return new StringTypes(cases, transformations);
     }
@@ -64,7 +68,7 @@ class StringTypes {
             return this;
         const kinds = new Set();
         for (const kind of this.transformations) {
-            const mapped = TypeBuilder_1.stringTypeMappingGet(mapping, kind);
+            const mapped = (0, TypeBuilder_1.stringTypeMappingGet)(mapping, kind);
             if (mapped === "string")
                 return StringTypes.unrestricted;
             kinds.add(mapped);
@@ -74,11 +78,11 @@ class StringTypes {
     equals(other) {
         if (!(other instanceof StringTypes))
             return false;
-        return collection_utils_1.areEqual(this.cases, other.cases) && collection_utils_1.areEqual(this.transformations, other.transformations);
+        return (0, collection_utils_1.areEqual)(this.cases, other.cases) && (0, collection_utils_1.areEqual)(this.transformations, other.transformations);
     }
     hashCode() {
-        let h = collection_utils_1.hashCodeOf(this.cases);
-        h = collection_utils_1.addHashCode(h, collection_utils_1.hashCodeOf(this.transformations));
+        let h = (0, collection_utils_1.hashCodeOf)(this.cases);
+        h = (0, collection_utils_1.addHashCode)(h, (0, collection_utils_1.hashCodeOf)(this.transformations));
         return h;
     }
     toString() {
@@ -88,7 +92,7 @@ class StringTypes {
             parts.push("unrestricted");
         }
         else {
-            const firstKey = collection_utils_1.iterableFirst(enumCases.keys());
+            const firstKey = (0, collection_utils_1.iterableFirst)(enumCases.keys());
             if (firstKey === undefined) {
                 parts.push("enum with no cases");
             }
@@ -99,7 +103,6 @@ class StringTypes {
         return parts.concat(Array.from(this.transformations)).join(",");
     }
 }
-StringTypes.unrestricted = new StringTypes(undefined, new Set());
 exports.StringTypes = StringTypes;
 class StringTypesTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
     constructor() {
@@ -112,11 +115,11 @@ class StringTypesTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
         return st.cases !== undefined && st.cases.size > 0;
     }
     combine(arr) {
-        Support_1.assert(arr.length > 0);
+        (0, Support_1.assert)(arr.length > 0);
         return arr[0].union(arr, 1);
     }
     intersect(arr) {
-        Support_1.assert(arr.length > 0);
+        (0, Support_1.assert)(arr.length > 0);
         return arr[0].intersect(arr, 1);
     }
     makeInferred(_) {

package/dist/quicktype-core/attributes/TypeAttributes.d.ts

@@ -13,7 +13,7 @@ export declare class TypeAttributeKind<T> {
     }, _t: Type, _attrs: T): void;
     children(_: T): ReadonlySet<Type>;
     stringify(_: T): string | undefined;
-    readonly inIdentity: boolean;
+    get inIdentity(): boolean;
     requiresUniqueIdentity(_: T): boolean;
     reconstitute<TBuilder extends BaseGraphRewriteBuilder>(_builder: TBuilder, a: T): T;
     makeAttributes(value: T): TypeAttributes;
@@ -25,9 +25,9 @@ export declare class TypeAttributeKind<T> {
     equals(other: any): boolean;
     hashCode(): number;
 }
-export declare type TypeAttributes = ReadonlyMap<TypeAttributeKind<any>, any>;
+export type TypeAttributes = ReadonlyMap<TypeAttributeKind<any>, any>;
 export declare const emptyTypeAttributes: TypeAttributes;
-export declare type CombinationKind = "union" | "intersect";
+export type CombinationKind = "union" | "intersect";
 export declare function combineTypeAttributes(kind: CombinationKind, attributeArray: TypeAttributes[]): TypeAttributes;
 export declare function combineTypeAttributes(kind: CombinationKind, a: TypeAttributes, b: TypeAttributes): TypeAttributes;
 export declare function makeTypeAttributesInferred(attr: TypeAttributes): TypeAttributes;

package/dist/quicktype-core/attributes/TypeAttributes.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.increaseTypeAttributesDistance = exports.makeTypeAttributesInferred = exports.combineTypeAttributes = exports.emptyTypeAttributes = exports.TypeAttributeKind = void 0;
 const collection_utils_1 = require("collection-utils");
 const Support_1 = require("../support/Support");
 class TypeAttributeKind {
+    name;
     constructor(name) {
         this.name = name;
     }
@@ -10,13 +12,13 @@ class TypeAttributeKind {
         return kind !== "any";
     }
     combine(_attrs) {
-        return Support_1.panic(`Cannot combine type attribute ${this.name}`);
+        return (0, Support_1.panic)(`Cannot combine type attribute ${this.name}`);
     }
     intersect(attrs) {
         return this.combine(attrs);
     }
     makeInferred(_) {
-        return Support_1.panic(`Cannot make type attribute ${this.name} inferred`);
+        return (0, Support_1.panic)(`Cannot make type attribute ${this.name} inferred`);
     }
     increaseDistance(attrs) {
         return attrs;
@@ -66,7 +68,7 @@ class TypeAttributeKind {
         return this.modifyInAttributes(a, makeDefault);
     }
     removeInAttributes(a) {
-        return collection_utils_1.mapFilter(a, (_, k) => k !== this);
+        return (0, collection_utils_1.mapFilter)(a, (_, k) => k !== this);
     }
     equals(other) {
         if (!(other instanceof TypeAttributeKind)) {
@@ -75,7 +77,7 @@ class TypeAttributeKind {
         return this.name === other.name;
     }
     hashCode() {
-        return collection_utils_1.hashString(this.name);
+        return (0, collection_utils_1.hashString)(this.name);
     }
 }
 exports.TypeAttributeKind = TypeAttributeKind;
@@ -88,13 +90,13 @@ function combineTypeAttributes(combinationKind, firstOrArray, second) {
     }
     else {
         if (second === undefined) {
-            return Support_1.panic("Must have on array or two attributes");
+            return (0, Support_1.panic)("Must have on array or two attributes");
         }
         attributeArray = [firstOrArray, second];
     }
-    const attributesByKind = collection_utils_1.mapTranspose(attributeArray);
+    const attributesByKind = (0, collection_utils_1.mapTranspose)(attributeArray);
     function combine(attrs, kind) {
-        Support_1.assert(attrs.length > 0, "Cannot combine zero type attributes");
+        (0, Support_1.assert)(attrs.length > 0, "Cannot combine zero type attributes");
         if (attrs.length === 1)
             return attrs[0];
         if (union) {
@@ -104,14 +106,14 @@ function combineTypeAttributes(combinationKind, firstOrArray, second) {
             return kind.intersect(attrs);
         }
     }
-    return collection_utils_1.mapFilterMap(attributesByKind, combine);
+    return (0, collection_utils_1.mapFilterMap)(attributesByKind, combine);
 }
 exports.combineTypeAttributes = combineTypeAttributes;
 function makeTypeAttributesInferred(attr) {
-    return collection_utils_1.mapFilterMap(attr, (value, kind) => kind.makeInferred(value));
+    return (0, collection_utils_1.mapFilterMap)(attr, (value, kind) => kind.makeInferred(value));
 }
 exports.makeTypeAttributesInferred = makeTypeAttributesInferred;
 function increaseTypeAttributesDistance(attr) {
-    return collection_utils_1.mapFilterMap(attr, (value, kind) => kind.increaseDistance(value));
+    return (0, collection_utils_1.mapFilterMap)(attr, (value, kind) => kind.increaseDistance(value));
 }
 exports.increaseTypeAttributesDistance = increaseTypeAttributesDistance;

package/dist/quicktype-core/attributes/TypeNames.d.ts

@@ -1,16 +1,16 @@
 import { TypeAttributeKind, TypeAttributes } from "./TypeAttributes";
 export declare function initTypeNames(): void;
-export declare type NameOrNames = string | TypeNames;
+export type NameOrNames = string | TypeNames;
 export declare const tooManyNamesThreshold = 1000;
 export declare abstract class TypeNames {
     readonly distance: number;
     static makeWithDistance(names: ReadonlySet<string>, alternativeNames: ReadonlySet<string> | undefined, distance: number): TypeNames;
     static make(names: ReadonlySet<string>, alternativeNames: ReadonlySet<string> | undefined, areInferred: boolean): TypeNames;
     constructor(distance: number);
-    readonly areInferred: boolean;
-    abstract readonly names: ReadonlySet<string>;
-    abstract readonly combinedName: string;
-    abstract readonly proposedNames: ReadonlySet<string>;
+    get areInferred(): boolean;
+    abstract get names(): ReadonlySet<string>;
+    abstract get combinedName(): string;
+    abstract get proposedNames(): ReadonlySet<string>;
     abstract add(namesArray: TypeNames[], startIndex?: number): TypeNames;
     abstract clearInferred(): TypeNames;
     abstract makeInferred(): TypeNames;
@@ -23,8 +23,8 @@ export declare class RegularTypeNames extends TypeNames {
     constructor(names: ReadonlySet<string>, _alternativeNames: ReadonlySet<string> | undefined, distance: number);
     add(namesArray: TypeNames[], startIndex?: number): TypeNames;
     clearInferred(): TypeNames;
-    readonly combinedName: string;
-    readonly proposedNames: ReadonlySet<string>;
+    get combinedName(): string;
+    get proposedNames(): ReadonlySet<string>;
     makeInferred(): TypeNames;
     singularize(): TypeNames;
     toString(): string;
@@ -32,8 +32,8 @@ export declare class RegularTypeNames extends TypeNames {
 export declare class TooManyTypeNames extends TypeNames {
     readonly names: ReadonlySet<string>;
     constructor(distance: number, name?: string);
-    readonly combinedName: string;
-    readonly proposedNames: ReadonlySet<string>;
+    get combinedName(): string;
+    get proposedNames(): ReadonlySet<string>;
     add(namesArray: TypeNames[], startIndex?: number): TypeNames;
     clearInferred(): TypeNames;
     makeInferred(): TypeNames;

package/dist/quicktype-core/attributes/TypeNames.js

@@ -1,6 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const pluralize = require("pluralize");
+exports.makeNamesTypeAttributes = exports.singularizeTypeNames = exports.modifyTypeNames = exports.namesTypeAttributeKind = exports.TooManyTypeNames = exports.RegularTypeNames = exports.TypeNames = exports.tooManyNamesThreshold = exports.initTypeNames = void 0;
+const pluralize = __importStar(require("pluralize"));
 const collection_utils_1 = require("collection-utils");
 const Support_1 = require("../support/Support");
 const TypeAttributes_1 = require("./TypeAttributes");
@@ -28,23 +52,23 @@ function makeRandomName() {
 // the names "aaa" and "aaaa" we have the common prefix "aaa" and the
 // common suffix "aaa", so we will produce the combined name "aaaaaa".
 function combineNames(names) {
-    let originalFirst = collection_utils_1.iterableFirst(names);
+    let originalFirst = (0, collection_utils_1.iterableFirst)(names);
     if (originalFirst === undefined) {
-        return Support_1.panic("Named type has no names");
+        return (0, Support_1.panic)("Named type has no names");
     }
     if (names.size === 1) {
         return originalFirst;
     }
-    const namesSet = collection_utils_1.setMap(names, s => Strings_1.splitIntoWords(s)
+    const namesSet = (0, collection_utils_1.setMap)(names, s => (0, Strings_1.splitIntoWords)(s)
         .map(w => w.word.toLowerCase())
         .join("_"));
-    const first = Support_1.defined(collection_utils_1.iterableFirst(namesSet));
+    const first = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(namesSet));
     if (namesSet.size === 1) {
         return first;
     }
     let prefixLength = first.length;
     let suffixLength = first.length;
-    for (const n of collection_utils_1.iterableSkip(namesSet, 1)) {
+    for (const n of (0, collection_utils_1.iterableSkip)(namesSet, 1)) {
         prefixLength = Math.min(prefixLength, n.length);
         for (let i = 0; i < prefixLength; i++) {
             if (first[i] !== n[i]) {
@@ -70,9 +94,7 @@ function combineNames(names) {
 }
 exports.tooManyNamesThreshold = 1000;
 class TypeNames {
-    constructor(distance) {
-        this.distance = distance;
-    }
+    distance;
     static makeWithDistance(names, alternativeNames, distance) {
         if (names.size >= exports.tooManyNamesThreshold) {
             return new TooManyTypeNames(distance);
@@ -85,12 +107,17 @@ class TypeNames {
     static make(names, alternativeNames, areInferred) {
         return TypeNames.makeWithDistance(names, alternativeNames, areInferred ? 1 : 0);
     }
+    constructor(distance) {
+        this.distance = distance;
+    }
     get areInferred() {
         return this.distance > 0;
     }
 }
 exports.TypeNames = TypeNames;
 class RegularTypeNames extends TypeNames {
+    names;
+    _alternativeNames;
     constructor(names, _alternativeNames, distance) {
         super(distance);
         this.names = names;
@@ -99,19 +126,19 @@ class RegularTypeNames extends TypeNames {
     add(namesArray, startIndex = 0) {
         let newNames = new Set(this.names);
         let newDistance = this.distance;
-        let newAlternativeNames = collection_utils_1.definedMap(this._alternativeNames, s => new Set(s));
+        let newAlternativeNames = (0, collection_utils_1.definedMap)(this._alternativeNames, s => new Set(s));
         for (let i = startIndex; i < namesArray.length; i++) {
             const other = namesArray[i];
             if (other instanceof RegularTypeNames && other._alternativeNames !== undefined) {
                 if (newAlternativeNames === undefined) {
                     newAlternativeNames = new Set();
                 }
-                collection_utils_1.setUnionInto(newAlternativeNames, other._alternativeNames);
+                (0, collection_utils_1.setUnionInto)(newAlternativeNames, other._alternativeNames);
             }
             if (other.distance > newDistance)
                 continue;
             if (!(other instanceof RegularTypeNames)) {
-                Support_1.assert(other instanceof TooManyTypeNames, "Unknown TypeNames instance");
+                (0, Support_1.assert)(other instanceof TooManyTypeNames, "Unknown TypeNames instance");
                 // The other one is at most our distance, so let it sort it out
                 return other.add(namesArray, i + 1);
             }
@@ -119,12 +146,12 @@ class RegularTypeNames extends TypeNames {
                 // The other one is closer, so take its names
                 newNames = new Set(other.names);
                 newDistance = other.distance;
-                newAlternativeNames = collection_utils_1.definedMap(other._alternativeNames, s => new Set(s));
+                newAlternativeNames = (0, collection_utils_1.definedMap)(other._alternativeNames, s => new Set(s));
             }
             else {
                 // Same distance, merge them
-                Support_1.assert(other.distance === newDistance, "This should be the only case left");
-                collection_utils_1.setUnionInto(newNames, other.names);
+                (0, Support_1.assert)(other.distance === newDistance, "This should be the only case left");
+                (0, collection_utils_1.setUnionInto)(newNames, other.names);
             }
         }
         return TypeNames.makeWithDistance(newNames, newAlternativeNames, newDistance);
@@ -141,14 +168,14 @@ class RegularTypeNames extends TypeNames {
         if (this._alternativeNames === undefined) {
             return set;
         }
-        collection_utils_1.setUnionInto(set, this._alternativeNames);
+        (0, collection_utils_1.setUnionInto)(set, this._alternativeNames);
         return set;
     }
     makeInferred() {
         return TypeNames.makeWithDistance(this.names, this._alternativeNames, this.distance + 1);
     }
     singularize() {
-        return TypeNames.makeWithDistance(collection_utils_1.setMap(this.names, pluralize.singular), collection_utils_1.definedMap(this._alternativeNames, an => collection_utils_1.setMap(an, pluralize.singular)), this.distance + 1);
+        return TypeNames.makeWithDistance((0, collection_utils_1.setMap)(this.names, pluralize.singular), (0, collection_utils_1.definedMap)(this._alternativeNames, an => (0, collection_utils_1.setMap)(an, pluralize.singular)), this.distance + 1);
     }
     toString() {
         const inferred = this.areInferred ? `distance ${this.distance}` : "given";
@@ -161,6 +188,7 @@ class RegularTypeNames extends TypeNames {
 }
 exports.RegularTypeNames = RegularTypeNames;
 class TooManyTypeNames extends TypeNames {
+    names;
     constructor(distance, name) {
         super(distance);
         if (name === undefined) {
@@ -169,7 +197,7 @@ class TooManyTypeNames extends TypeNames {
         this.names = new Set([name]);
     }
     get combinedName() {
-        return Support_1.defined(collection_utils_1.iterableFirst(this.names));
+        return (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(this.names));
     }
     get proposedNames() {
         return this.names;
@@ -192,7 +220,7 @@ class TooManyTypeNames extends TypeNames {
         return TypeNames.makeWithDistance(new Set(), new Set(), this.distance);
     }
     makeInferred() {
-        return new TooManyTypeNames(this.distance + 1, collection_utils_1.iterableFirst(this.names));
+        return new TooManyTypeNames(this.distance + 1, (0, collection_utils_1.iterableFirst)(this.names));
     }
     singularize() {
         return this;
@@ -207,7 +235,7 @@ class TypeNamesTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
         super("names");
     }
     combine(namesArray) {
-        Support_1.assert(namesArray.length > 0, "Can't combine zero type names");
+        (0, Support_1.assert)(namesArray.length > 0, "Can't combine zero type names");
         return namesArray[0].add(namesArray, 1);
     }
     makeInferred(tn) {
@@ -236,7 +264,7 @@ exports.singularizeTypeNames = singularizeTypeNames;
 function makeNamesTypeAttributes(nameOrNames, areNamesInferred) {
     let typeNames;
     if (typeof nameOrNames === "string") {
-        typeNames = TypeNames.make(new Set([nameOrNames]), new Set(), Support_1.defined(areNamesInferred));
+        typeNames = TypeNames.make(new Set([nameOrNames]), new Set(), (0, Support_1.defined)(areNamesInferred));
     }
     else {
         typeNames = nameOrNames;

package/dist/quicktype-core/attributes/URIAttributes.d.ts

@@ -1,7 +1,7 @@
 import { TypeAttributeKind, TypeAttributes } from "./TypeAttributes";
 import { JSONSchemaType, JSONSchemaAttributes, Ref } from "../input/JSONSchemaInput";
 import { JSONSchema } from "../input/JSONSchemaStore";
-declare type URIAttributes = [ReadonlySet<string>, ReadonlySet<string>];
+type URIAttributes = [ReadonlySet<string>, ReadonlySet<string>];
 export declare const uriTypeAttributeKind: TypeAttributeKind<URIAttributes>;
 export declare function uriInferenceAttributesProducer(s: string): TypeAttributes;
 export declare function uriSchemaAttributesProducer(schema: JSONSchema, _ref: Ref, types: Set<JSONSchemaType>): JSONSchemaAttributes | undefined;

package/dist/quicktype-core/attributes/URIAttributes.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const URI = require("urijs");
+exports.uriSchemaAttributesProducer = exports.uriInferenceAttributesProducer = exports.uriTypeAttributeKind = void 0;
+const urijs_1 = __importDefault(require("urijs"));
 const TypeAttributes_1 = require("./TypeAttributes");
 const collection_utils_1 = require("collection-utils");
 const Support_1 = require("../support/Support");
@@ -16,7 +20,7 @@ class URITypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
     combine(attrs) {
         const protocolSets = attrs.map(a => a[0]);
         const extensionSets = attrs.map(a => a[1]);
-        return [collection_utils_1.setUnionManyInto(new Set(), protocolSets), collection_utils_1.setUnionManyInto(new Set(), extensionSets)];
+        return [(0, collection_utils_1.setUnionManyInto)(new Set(), protocolSets), (0, collection_utils_1.setUnionManyInto)(new Set(), extensionSets)];
     }
     makeInferred(_) {
         return undefined;
@@ -43,12 +47,12 @@ function pathExtension(path) {
 }
 function uriInferenceAttributesProducer(s) {
     try {
-        const uri = URI(s);
+        const uri = (0, urijs_1.default)(s);
         const extension = pathExtension(uri.path());
         const extensions = extension === undefined ? [] : [extension.toLowerCase()];
         return exports.uriTypeAttributeKind.makeAttributes([new Set([uri.protocol().toLowerCase()]), new Set(extensions)]);
     }
-    catch (_a) {
+    catch {
         return TypeAttributes_1.emptyTypeAttributes;
     }
 }
@@ -61,7 +65,7 @@ function uriSchemaAttributesProducer(schema, _ref, types) {
     let protocols;
     const maybeProtocols = schema[protocolsSchemaProperty];
     if (maybeProtocols !== undefined) {
-        protocols = new Set(Support_1.checkArray(maybeProtocols, Support_1.checkString));
+        protocols = new Set((0, Support_1.checkArray)(maybeProtocols, Support_1.checkString));
     }
     else {
         protocols = new Set();
@@ -69,7 +73,7 @@ function uriSchemaAttributesProducer(schema, _ref, types) {
     let extensions;
     const maybeExtensions = schema[extensionsSchemaProperty];
     if (maybeExtensions !== undefined) {
-        extensions = new Set(Support_1.checkArray(maybeExtensions, Support_1.checkString));
+        extensions = new Set((0, Support_1.checkArray)(maybeExtensions, Support_1.checkString));
     }
     else {
         extensions = new Set();