quicktype 18.0.6 → 19.0.4

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

@@ -1,47 +0,0 @@
-"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");
-const TypeUtils_1 = require("../TypeUtils");
-const Support_1 = require("../support/Support");
-const UnifyClasses_1 = require("../UnifyClasses");
-const Messages_1 = require("../Messages");
-const TypeAttributes_1 = require("../attributes/TypeAttributes");
-function flattenUnions(graph, stringTypeMapping, conflateNumbers, makeObjectTypes, debugPrintReconstitution) {
-    let needsRepeat = false;
-    function replace(types, builder, forwardingRef) {
-        const unionBuilder = new UnifyClasses_1.UnifyUnionBuilder(builder, makeObjectTypes, true, trefs => {
-            (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 (0, UnifyClasses_1.unifyTypes)(types, TypeAttributes_1.emptyTypeAttributes, builder, unionBuilder, conflateNumbers, forwardingRef);
-    }
-    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 = (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
-        // unions that might require flattening, so now `flattenUnions` needs to take
-        // that into account.  Either change `resolveIntersections` such that it
-        // doesn't introduce non-canonical unions (by using `unifyTypes`), or have
-        // some other way to tell whether more work is needed that doesn't require
-        // the two passes to know about each other.
-        foundIntersection = true;
-        return false;
-    });
-    graph = graph.rewrite("flatten unions", stringTypeMapping, false, groups, debugPrintReconstitution, replace);
-    // console.log(`flattened ${nonCanonicalUnions.size} of ${unions.size} unions`);
-    return [graph, !needsRepeat && !foundIntersection];
-}
-exports.flattenUnions = flattenUnions;

package/dist/quicktype-core/rewrites/InferMaps.d.ts

@@ -1,3 +0,0 @@
-import { TypeGraph } from "../TypeGraph";
-import { StringTypeMapping } from "../TypeBuilder";
-export declare function inferMaps(graph: TypeGraph, stringTypeMapping: StringTypeMapping, conflateNumbers: boolean, debugPrintReconstitution: boolean): TypeGraph;

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

@@ -1,117 +0,0 @@
-"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");
-const Support_1 = require("../support/Support");
-const UnifyClasses_1 = require("../UnifyClasses");
-const MarkovChain_1 = require("../MarkovChain");
-const mapSizeThreshold = 20;
-const stringMapSizeThreshold = 50;
-let markovChain = undefined;
-function nameProbability(name) {
-    if (markovChain === undefined) {
-        markovChain = (0, MarkovChain_1.load)();
-    }
-    return (0, MarkovChain_1.evaluate)(markovChain, name);
-}
-function shouldBeMap(properties) {
-    // Only classes with a certain number of properties are inferred
-    // as maps.
-    const numProperties = properties.size;
-    if (numProperties < 2)
-        return undefined;
-    // If all property names are digit-only, we always make a map, no
-    // questions asked.
-    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 &&
-        (0, collection_utils_1.iterableEvery)(properties.values(), cp => (0, Type_1.isPrimitiveStringTypeKind)(cp.type.kind) || cp.type.kind === "null")) {
-        return undefined;
-    }
-    if (numProperties < mapSizeThreshold) {
-        const names = Array.from(properties.keys());
-        const probabilities = names.map(nameProbability);
-        const product = probabilities.reduce((a, b) => a * b, 1);
-        const probability = Math.pow(product, 1 / numProperties);
-        // The idea behind this is to have a probability around 0.0025 for
-        // n=1, up to around 1.0 for n=20.  I.e. when we only have a few
-        // properties, they need to look really weird to infer a map, but
-        // when we have more we'll accept more ordinary names.  The details
-        // of the formula are immaterial because I pulled it out of my ass.
-        // FIXME: Use different exponents and start values depending on
-        // the property type kind.  For string properties, for example, we
-        // should be more conservative, with class properties more
-        // aggressive.  An exponent of 6 is probably good for string
-        // properties, and maybe a start value of 0.002, whereas for classes
-        // we want maybe 0.004 and 5, or maybe something even more
-        // trigger-happy.
-        const exponent = 5;
-        const scale = Math.pow(22, exponent);
-        const limit = Math.pow(numProperties + 2, exponent) / scale + (0.0025 - Math.pow(3, exponent) / scale);
-        if (probability > limit)
-            return undefined;
-    }
-    // FIXME: simplify this - it's no longer necessary with the new
-    // class properties.
-    // We need to handle three cases for maps (and the fourth case
-    // where we leave the class as is):
-    //
-    // 1. All property types are null.
-    // 2. Some property types are null or nullable.
-    // 3. No property types are null or nullable.
-    let firstNonNullCases = undefined;
-    const allCases = new Set();
-    let canBeMap = true;
-    // 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 = (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 (!(0, Type_1.setOperationCasesEqual)(nn, firstNonNullCases, true, (a, b) => a.structurallyCompatible(b, true))) {
-                    canBeMap = false;
-                    break;
-                }
-            }
-            else {
-                firstNonNullCases = nn;
-            }
-        }
-        allCases.add(p.type);
-    }
-    if (!canBeMap) {
-        return undefined;
-    }
-    return allCases;
-}
-function inferMaps(graph, stringTypeMapping, conflateNumbers, debugPrintReconstitution) {
-    function replaceClass(setOfOneClass, builder, forwardingRef) {
-        const c = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(setOfOneClass));
-        const properties = c.getProperties();
-        const shouldBe = shouldBeMap(properties);
-        if (shouldBe === undefined) {
-            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
-        // graph, and the types in the new graph are different objects.
-        // 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(), (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))
-            return false;
-        return !o.isFixed && shouldBeMap(o.getProperties()) !== undefined;
-    });
-    return graph.rewrite("infer maps", stringTypeMapping, false, classesToReplace.map(c => [c]), debugPrintReconstitution, replaceClass);
-}
-exports.inferMaps = inferMaps;

package/dist/quicktype-core/rewrites/ReplaceObjectType.d.ts

@@ -1,3 +0,0 @@
-import { TypeGraph } from "../TypeGraph";
-import { StringTypeMapping } from "../TypeBuilder";
-export declare function replaceObjectType(graph: TypeGraph, stringTypeMapping: StringTypeMapping, _conflateNumbers: boolean, leaveFullObjects: boolean, debugPrintReconstitution: boolean): TypeGraph;

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

@@ -1,60 +0,0 @@
-"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 = (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 (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((0, Support_1.defined)(additionalProperties));
-        }
-        if (additionalProperties === undefined) {
-            return makeClass();
-        }
-        if (properties.size === 0) {
-            return builder.getMapType(attributes, reconstituteAdditionalProperties(), forwardingRef);
-        }
-        if (additionalProperties.kind === "any") {
-            // FIXME: Warn that we're losing additional property semantics.
-            builder.setLostTypeAttributes();
-            return makeClass();
-        }
-        // FIXME: Warn that we're losing class semantics.
-        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 = (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.
-            /*
-            union = unifyTypes(
-                propertyTypes,
-                combineTypeAttributes(propertyTypes.toArray().map(t => t.getAttributes())),
-                builder,
-                unionBuilderForUnification(builder, false, false, false, conflateNumbers),
-                conflateNumbers
-            );
-            */
-        }
-        return builder.getMapType(attributes, union, forwardingRef);
-    }
-    const allObjectTypes = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), t => t.kind === "object");
-    const objectTypesToReplace = leaveFullObjects
-        ? (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);
-}
-exports.replaceObjectType = replaceObjectType;

package/dist/quicktype-core/rewrites/ResolveIntersections.d.ts

@@ -1,3 +0,0 @@
-import { TypeGraph } from "../TypeGraph";
-import { StringTypeMapping } from "../TypeBuilder";
-export declare function resolveIntersections(graph: TypeGraph, stringTypeMapping: StringTypeMapping, debugPrintReconstitution: boolean): [TypeGraph, boolean];

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

@@ -1,244 +0,0 @@
-"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");
-const TypeUtils_1 = require("../TypeUtils");
-const Support_1 = require("../support/Support");
-const TypeAttributes_1 = require("../attributes/TypeAttributes");
-function canResolve(t) {
-    const members = (0, TypeUtils_1.setOperationMembersRecursively)(t, undefined)[0];
-    if (members.size <= 1)
-        return true;
-    return (0, collection_utils_1.iterableEvery)(members, m => !(m instanceof Type_1.UnionType) || m.isCanonical);
-}
-function attributesForTypes(types) {
-    return (0, collection_utils_1.mapMapEntries)(types.entries(), t => [t.kind, t.getAttributes()]);
-}
-class IntersectionAccumulator {
-    _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 = (0, collection_utils_1.setFilter)(members, t => (0, Type_1.isPrimitiveTypeKind)(t.kind));
-        const attributes = attributesForTypes(types);
-        (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 = (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 = (0, collection_utils_1.iterableFind)(members, t => t instanceof Type_1.ArrayType);
-        if (maybeArray === undefined) {
-            this._arrayItemTypes = false;
-            return;
-        }
-        this._arrayAttributes = (0, TypeAttributes_1.combineTypeAttributes)("intersect", this._arrayAttributes, maybeArray.getAttributes());
-        if (this._arrayItemTypes === undefined) {
-            this._arrayItemTypes = new Set();
-        }
-        else if (this._arrayItemTypes !== false) {
-            this._arrayItemTypes.add(maybeArray.items);
-        }
-    }
-    updateObjectProperties(members) {
-        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 = (0, TypeAttributes_1.combineTypeAttributes)("intersect", this._objectAttributes, maybeObject.getAttributes());
-        const objectAdditionalProperties = maybeObject.getAdditionalProperties();
-        if (this._objectProperties === undefined) {
-            (0, Support_1.assert)(this._additionalPropertyTypes === undefined);
-            return;
-        }
-        const allPropertyNames = (0, collection_utils_1.setUnionInto)(new Set(this._objectProperties.keys()), maybeObject.getProperties().keys());
-        for (const name of allPropertyNames) {
-            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);
-                (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);
-                (0, Support_1.defined)(this._objectProperties).set(name, cp);
-            }
-            else if (existing !== undefined) {
-                (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);
-                (0, Support_1.defined)(this._objectProperties).set(name, new Type_1.GenericClassProperty(types, newProperty.isOptional));
-            }
-            else if (newProperty !== undefined) {
-                (0, Support_1.defined)(this._objectProperties).delete(name);
-            }
-            else {
-                return (0, Support_1.mustNotHappen)();
-            }
-        }
-        if (this._additionalPropertyTypes !== undefined && objectAdditionalProperties !== undefined) {
-            this._additionalPropertyTypes.add(objectAdditionalProperties);
-        }
-        else if (this._additionalPropertyTypes !== undefined || objectAdditionalProperties !== undefined) {
-            this._additionalPropertyTypes = undefined;
-            this._lostTypeAttributes = true;
-        }
-    }
-    addUnionSet(members) {
-        this.updatePrimitiveTypes(members);
-        this.updateArrayItemTypes(members);
-        this.updateObjectProperties(members);
-    }
-    addType(t) {
-        let attributes = t.getAttributes();
-        (0, TypeUtils_1.matchTypeExhaustive)(t, _noneType => {
-            return (0, Support_1.panic)("There shouldn't be a none type");
-        }, _anyType => {
-            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 (0, TypeAttributes_1.makeTypeAttributesInferred)(attributes);
-    }
-    get arrayData() {
-        if (this._arrayItemTypes === undefined || this._arrayItemTypes === false) {
-            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) {
-            (0, Support_1.assert)(this._additionalPropertyTypes === undefined);
-            return undefined;
-        }
-        return [this._objectProperties, this._additionalPropertyTypes];
-    }
-    get enumCases() {
-        return (0, Support_1.panic)("We don't support enums in intersections");
-    }
-    getMemberKinds() {
-        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?
-            (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) {
-            kinds.set("array", this._arrayAttributes);
-        }
-        else if (this._arrayAttributes.size > 0) {
-            this._lostTypeAttributes = true;
-        }
-        if (this._objectProperties !== undefined) {
-            kinds.set("object", this._objectAttributes);
-        }
-        else if (this._objectAttributes.size > 0) {
-            this._lostTypeAttributes = true;
-        }
-        return kinds;
-    }
-    get lostTypeAttributes() {
-        return this._lostTypeAttributes;
-    }
-}
-class IntersectionUnionBuilder extends UnionBuilder_1.UnionBuilder {
-    _createdNewIntersections = false;
-    makeIntersection(members, attributes) {
-        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;
-        }
-        this._createdNewIntersections = true;
-        return this.typeBuilder.getUniqueIntersectionType(attributes, reconstitutedMembers);
-    }
-    get createdNewIntersections() {
-        return this._createdNewIntersections;
-    }
-    makeObject(maybeData, typeAttributes, forwardingRef) {
-        if (maybeData === undefined) {
-            return (0, Support_1.panic)("Either properties or additional properties must be given to make an object type");
-        }
-        const [propertyTypes, maybeAdditionalProperties] = maybeData;
-        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);
-        return this.typeBuilder.getUniqueObjectType(typeAttributes, properties, additionalProperties, forwardingRef);
-    }
-    makeArray(arrays, typeAttributes, forwardingRef) {
-        // FIXME: attributes
-        const itemsType = this.makeIntersection(arrays, TypeAttributes_1.emptyTypeAttributes);
-        const tref = this.typeBuilder.getArrayType(typeAttributes, itemsType, forwardingRef);
-        return tref;
-    }
-}
-function resolveIntersections(graph, stringTypeMapping, debugPrintReconstitution) {
-    let needsRepeat = false;
-    function replace(types, builder, forwardingRef) {
-        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((0, Support_1.defined)((0, collection_utils_1.iterableFirst)(members)), intersectionAttributes, forwardingRef);
-        }
-        const accumulator = new IntersectionAccumulator();
-        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) {
-            needsRepeat = true;
-        }
-        return tref;
-    }
-    // FIXME: We need to handle intersections that resolve to the same set of types.
-    // See for example the intersections-nested.schema example.
-    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];
-}
-exports.resolveIntersections = resolveIntersections;

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

@@ -1,10 +0,0 @@
-import { EnumOption } from "../RendererOptions";
-export declare const acronyms: string[];
-export declare enum AcronymStyleOptions {
-    Pascal = "pascal",
-    Camel = "camel",
-    Original = "original",
-    Lower = "lowerCase"
-}
-export declare const acronymOption: (defaultOption: AcronymStyleOptions) => EnumOption<AcronymStyleOptions>;
-export declare function acronymStyle(style: AcronymStyleOptions): (s: string) => string;