quicktype 18.0.5 → 19.0.4

package/dist/quicktype-core/GraphRewriting.js

@@ -1,421 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GraphRewriteBuilder = exports.GraphRemapBuilder = exports.BaseGraphRewriteBuilder = exports.TypeReconstituter = void 0;
-const collection_utils_1 = require("collection-utils");
-const TypeUtils_1 = require("./TypeUtils");
-const TypeGraph_1 = require("./TypeGraph");
-const TypeAttributes_1 = require("./attributes/TypeAttributes");
-const Support_1 = require("./support/Support");
-const TypeBuilder_1 = require("./TypeBuilder");
-class TypeReconstituter {
-    _typeBuilder;
-    _makeClassUnique;
-    _typeAttributes;
-    _forwardingRef;
-    _register;
-    _wasUsed = false;
-    _typeRef = undefined;
-    constructor(_typeBuilder, _makeClassUnique, _typeAttributes, _forwardingRef, _register) {
-        this._typeBuilder = _typeBuilder;
-        this._makeClassUnique = _makeClassUnique;
-        this._typeAttributes = _typeAttributes;
-        this._forwardingRef = _forwardingRef;
-        this._register = _register;
-    }
-    builderForNewType() {
-        (0, Support_1.assert)(!this._wasUsed, "TypeReconstituter used more than once");
-        this._wasUsed = true;
-        return this._typeBuilder;
-    }
-    builderForSetting() {
-        (0, Support_1.assert)(this._wasUsed && this._typeRef !== undefined, "Can't set type members before constructing a type");
-        return this._typeBuilder;
-    }
-    getResult() {
-        if (this._typeRef === undefined) {
-            return (0, Support_1.panic)("Type was not reconstituted");
-        }
-        return this._typeRef;
-    }
-    // FIXME: Do registration automatically.
-    register(tref) {
-        (0, Support_1.assert)(this._typeRef === undefined, "Cannot register a type twice");
-        this._typeRef = tref;
-        this._register(tref);
-    }
-    registerAndAddAttributes(tref) {
-        this._typeBuilder.addAttributes(tref, this._typeAttributes);
-        this.register(tref);
-    }
-    lookup(trefs) {
-        (0, Support_1.assert)(!this._wasUsed, "Cannot lookup constituents after building type");
-        if ((0, TypeGraph_1.isTypeRef)(trefs)) {
-            return this._typeBuilder.lookupTypeRefs([trefs], undefined, false);
-        }
-        else {
-            const maybeRefs = Array.from(trefs).map(tref => this._typeBuilder.lookupTypeRefs([tref], undefined, false));
-            if (maybeRefs.some(tref => tref === undefined))
-                return undefined;
-            return maybeRefs;
-        }
-    }
-    lookupMap(trefs) {
-        const resultValues = this.lookup(trefs.values());
-        if (resultValues === undefined)
-            return undefined;
-        (0, Support_1.assert)(resultValues.length === trefs.size, "Didn't get back the correct number of types");
-        const result = new Map();
-        let i = 0;
-        for (const k of trefs.keys()) {
-            result.set(k, resultValues[i]);
-            i += 1;
-        }
-        return result;
-    }
-    reconstitute(trefs) {
-        (0, Support_1.assert)(this._wasUsed, "Cannot reconstitute constituents before building type");
-        if ((0, TypeGraph_1.isTypeRef)(trefs)) {
-            return this._typeBuilder.reconstituteTypeRef(trefs);
-        }
-        else {
-            return Array.from(trefs).map(tref => this._typeBuilder.reconstituteTypeRef(tref));
-        }
-    }
-    reconstituteMap(trefs) {
-        return (0, collection_utils_1.mapMap)(trefs, tref => this._typeBuilder.reconstituteTypeRef(tref));
-    }
-    getPrimitiveType(kind) {
-        this.register(this.builderForNewType().getPrimitiveType(kind, this._typeAttributes, this._forwardingRef));
-    }
-    getEnumType(cases) {
-        this.register(this.builderForNewType().getEnumType(this._typeAttributes, cases, this._forwardingRef));
-    }
-    getUniqueMapType() {
-        this.registerAndAddAttributes(this.builderForNewType().getUniqueMapType(this._forwardingRef));
-    }
-    getMapType(values) {
-        this.register(this.builderForNewType().getMapType(this._typeAttributes, values, this._forwardingRef));
-    }
-    getUniqueArrayType() {
-        this.registerAndAddAttributes(this.builderForNewType().getUniqueArrayType(this._forwardingRef));
-    }
-    getArrayType(items) {
-        this.register(this.builderForNewType().getArrayType(this._typeAttributes, items, this._forwardingRef));
-    }
-    setArrayItems(items) {
-        this.builderForSetting().setArrayItems(this.getResult(), items);
-    }
-    makeClassProperty(tref, isOptional) {
-        return this._typeBuilder.makeClassProperty(tref, isOptional);
-    }
-    getObjectType(properties, additionalProperties) {
-        this.register(this.builderForNewType().getUniqueObjectType(this._typeAttributes, properties, additionalProperties, this._forwardingRef));
-    }
-    getUniqueObjectType(properties, additionalProperties) {
-        this.register(this.builderForNewType().getUniqueObjectType(this._typeAttributes, properties, additionalProperties, this._forwardingRef));
-    }
-    getClassType(properties) {
-        if (this._makeClassUnique) {
-            this.getUniqueClassType(false, properties);
-            return;
-        }
-        this.register(this.builderForNewType().getClassType(this._typeAttributes, properties, this._forwardingRef));
-    }
-    getUniqueClassType(isFixed, properties) {
-        this.register(this.builderForNewType().getUniqueClassType(this._typeAttributes, isFixed, properties, this._forwardingRef));
-    }
-    setObjectProperties(properties, additionalProperties) {
-        this.builderForSetting().setObjectProperties(this.getResult(), properties, additionalProperties);
-    }
-    getUnionType(members) {
-        this.register(this.builderForNewType().getUnionType(this._typeAttributes, members, this._forwardingRef));
-    }
-    getUniqueUnionType() {
-        this.register(this.builderForNewType().getUniqueUnionType(this._typeAttributes, undefined, this._forwardingRef));
-    }
-    getIntersectionType(members) {
-        this.register(this.builderForNewType().getIntersectionType(this._typeAttributes, members, this._forwardingRef));
-    }
-    getUniqueIntersectionType(members) {
-        this.register(this.builderForNewType().getUniqueIntersectionType(this._typeAttributes, members, this._forwardingRef));
-    }
-    setSetOperationMembers(members) {
-        this.builderForSetting().setSetOperationMembers(this.getResult(), members);
-    }
-}
-exports.TypeReconstituter = TypeReconstituter;
-class BaseGraphRewriteBuilder extends TypeBuilder_1.TypeBuilder {
-    originalGraph;
-    debugPrint;
-    reconstitutedTypes = new Map();
-    _lostTypeAttributes = false;
-    _printIndent = 0;
-    constructor(originalGraph, stringTypeMapping, alphabetizeProperties, graphHasProvenanceAttributes, debugPrint) {
-        super(originalGraph.serial + 1, stringTypeMapping, alphabetizeProperties, false, false, graphHasProvenanceAttributes);
-        this.originalGraph = originalGraph;
-        this.debugPrint = debugPrint;
-    }
-    withForwardingRef(maybeForwardingRef, typeCreator) {
-        if (maybeForwardingRef !== undefined) {
-            return typeCreator(maybeForwardingRef);
-        }
-        const forwardingRef = this.reserveTypeRef();
-        const actualRef = typeCreator(forwardingRef);
-        (0, Support_1.assert)(actualRef === forwardingRef, "Type creator didn't return its forwarding ref");
-        return actualRef;
-    }
-    reconstituteType(t, attributes, forwardingRef) {
-        return this.reconstituteTypeRef(t.typeRef, attributes, forwardingRef);
-    }
-    reconstituteTypeRef(originalRef, attributes, maybeForwardingRef) {
-        const maybeRef = this.lookupTypeRefs([originalRef], maybeForwardingRef);
-        if (maybeRef !== undefined) {
-            if (attributes !== undefined) {
-                this.addAttributes(maybeRef, attributes);
-            }
-            return maybeRef;
-        }
-        return this.forceReconstituteTypeRef(originalRef, attributes, maybeForwardingRef);
-    }
-    reconstituteTypeAttributes(attributes) {
-        return (0, collection_utils_1.mapMap)(attributes, (v, a) => a.reconstitute(this, v));
-    }
-    assertTypeRefsToReconstitute(typeRefs, forwardingRef) {
-        (0, Support_1.assert)(typeRefs.length > 0, "Must have at least one type to reconstitute");
-        for (const originalRef of typeRefs) {
-            (0, TypeGraph_1.assertTypeRefGraph)(originalRef, this.originalGraph);
-        }
-        if (forwardingRef !== undefined) {
-            (0, TypeGraph_1.assertTypeRefGraph)(forwardingRef, this.typeGraph);
-        }
-    }
-    changeDebugPrintIndent(delta) {
-        this._printIndent += delta;
-    }
-    get debugPrintIndentation() {
-        return (0, Support_1.indentationString)(this._printIndent);
-    }
-    finish() {
-        for (const [name, t] of this.originalGraph.topLevels) {
-            this.addTopLevel(name, this.reconstituteType(t));
-        }
-        return super.finish();
-    }
-    setLostTypeAttributes() {
-        this._lostTypeAttributes = true;
-    }
-    get lostTypeAttributes() {
-        return this._lostTypeAttributes;
-    }
-}
-exports.BaseGraphRewriteBuilder = BaseGraphRewriteBuilder;
-class GraphRemapBuilder extends BaseGraphRewriteBuilder {
-    _map;
-    _attributeSources = new Map();
-    constructor(originalGraph, stringTypeMapping, alphabetizeProperties, graphHasProvenanceAttributes, _map, debugPrintRemapping) {
-        super(originalGraph, stringTypeMapping, alphabetizeProperties, graphHasProvenanceAttributes, debugPrintRemapping);
-        this._map = _map;
-        for (const [source, target] of _map) {
-            let maybeSources = this._attributeSources.get(target);
-            if (maybeSources === undefined) {
-                maybeSources = [target];
-                this._attributeSources.set(target, maybeSources);
-            }
-            maybeSources.push(source);
-        }
-    }
-    makeIdentity(_maker) {
-        return undefined;
-    }
-    getMapTarget(tref) {
-        const maybeType = this._map.get((0, TypeGraph_1.derefTypeRef)(tref, this.originalGraph));
-        if (maybeType === undefined)
-            return tref;
-        (0, Support_1.assert)(this._map.get(maybeType) === undefined, "We have a type that's remapped to a remapped type");
-        return maybeType.typeRef;
-    }
-    addForwardingIntersection(_forwardingRef, _tref) {
-        return (0, Support_1.panic)("We can't add forwarding intersections when we're removing forwarding intersections");
-    }
-    lookupTypeRefs(typeRefs, forwardingRef) {
-        (0, Support_1.assert)(forwardingRef === undefined, "We can't have a forwarding ref when we remap");
-        this.assertTypeRefsToReconstitute(typeRefs, forwardingRef);
-        const first = this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(this.getMapTarget(typeRefs[0])));
-        if (first === undefined)
-            return undefined;
-        for (let i = 1; i < typeRefs.length; i++) {
-            const other = this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(this.getMapTarget(typeRefs[i])));
-            if (first !== other)
-                return undefined;
-        }
-        return first;
-    }
-    forceReconstituteTypeRef(originalRef, attributes, maybeForwardingRef) {
-        originalRef = this.getMapTarget(originalRef);
-        const index = (0, TypeGraph_1.typeRefIndex)(originalRef);
-        (0, Support_1.assert)(this.reconstitutedTypes.get(index) === undefined, "Type has already been reconstituted");
-        (0, Support_1.assert)(maybeForwardingRef === undefined, "We can't have a forwarding ref when we remap");
-        return this.withForwardingRef(undefined, forwardingRef => {
-            this.reconstitutedTypes.set(index, forwardingRef);
-            if (this.debugPrint) {
-                console.log(`${this.debugPrintIndentation}reconstituting ${index} as ${(0, TypeGraph_1.typeRefIndex)(forwardingRef)}`);
-                this.changeDebugPrintIndent(1);
-            }
-            const [originalType, originalAttributes] = (0, TypeGraph_1.typeAndAttributesForTypeRef)(originalRef, this.originalGraph);
-            const attributeSources = this._attributeSources.get(originalType);
-            if (attributes === undefined) {
-                attributes = TypeAttributes_1.emptyTypeAttributes;
-            }
-            if (attributeSources === undefined) {
-                attributes = (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, this.reconstituteTypeAttributes(originalAttributes));
-            }
-            else {
-                attributes = (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, this.reconstituteTypeAttributes((0, TypeUtils_1.combineTypeAttributesOfTypes)("union", attributeSources)));
-            }
-            const newAttributes = attributes;
-            const reconstituter = new TypeReconstituter(this, this.canonicalOrder, newAttributes, forwardingRef, tref => {
-                (0, Support_1.assert)(tref === forwardingRef, "Reconstituted type as a different ref");
-                if (this.debugPrint) {
-                    this.changeDebugPrintIndent(-1);
-                    console.log(`${this.debugPrintIndentation}reconstituted ${index} as ${(0, TypeGraph_1.typeRefIndex)(tref)}`);
-                }
-            });
-            originalType.reconstitute(reconstituter, this.canonicalOrder);
-            return reconstituter.getResult();
-        });
-    }
-}
-exports.GraphRemapBuilder = GraphRemapBuilder;
-class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
-    _replacer;
-    _setsToReplaceByMember;
-    _reconstitutedUnions = new collection_utils_1.EqualityMap();
-    constructor(originalGraph, stringTypeMapping, alphabetizeProperties, graphHasProvenanceAttributes, setsToReplace, debugPrintReconstitution, _replacer) {
-        super(originalGraph, stringTypeMapping, alphabetizeProperties, graphHasProvenanceAttributes, debugPrintReconstitution);
-        this._replacer = _replacer;
-        this._setsToReplaceByMember = new Map();
-        for (const types of setsToReplace) {
-            const set = new Set(types);
-            for (const t of set) {
-                const index = t.index;
-                (0, Support_1.assert)(!this._setsToReplaceByMember.has(index), "A type is member of more than one set to be replaced");
-                this._setsToReplaceByMember.set(index, set);
-            }
-        }
-    }
-    registerUnion(typeRefs, reconstituted) {
-        const set = new Set(typeRefs);
-        (0, Support_1.assert)(!this._reconstitutedUnions.has(set), "Cannot register reconstituted set twice");
-        this._reconstitutedUnions.set(set, reconstituted);
-    }
-    replaceSet(typesToReplace, maybeForwardingRef) {
-        return this.withForwardingRef(maybeForwardingRef, forwardingRef => {
-            if (this.debugPrint) {
-                console.log(`${this.debugPrintIndentation}replacing set ${Array.from(typesToReplace)
-                    .map(t => t.index.toString())
-                    .join(",")} as ${(0, TypeGraph_1.typeRefIndex)(forwardingRef)}`);
-                this.changeDebugPrintIndent(1);
-            }
-            for (const t of typesToReplace) {
-                const originalRef = t.typeRef;
-                const index = (0, TypeGraph_1.typeRefIndex)(originalRef);
-                this.reconstitutedTypes.set(index, forwardingRef);
-                this._setsToReplaceByMember.delete(index);
-            }
-            const result = this._replacer(typesToReplace, this, forwardingRef);
-            (0, Support_1.assert)(result === forwardingRef, "The forwarding ref got lost when replacing");
-            if (this.debugPrint) {
-                this.changeDebugPrintIndent(-1);
-                console.log(`${this.debugPrintIndentation}replaced set ${Array.from(typesToReplace)
-                    .map(t => t.index.toString())
-                    .join(",")} as ${(0, TypeGraph_1.typeRefIndex)(forwardingRef)}`);
-            }
-            return result;
-        });
-    }
-    forceReconstituteTypeRef(originalRef, attributes, maybeForwardingRef) {
-        const [originalType, originalAttributes] = (0, TypeGraph_1.typeAndAttributesForTypeRef)(originalRef, this.originalGraph);
-        const index = (0, TypeGraph_1.typeRefIndex)(originalRef);
-        if (this.debugPrint) {
-            console.log(`${this.debugPrintIndentation}reconstituting ${index}`);
-            this.changeDebugPrintIndent(1);
-        }
-        if (attributes === undefined) {
-            attributes = this.reconstituteTypeAttributes(originalAttributes);
-        }
-        else {
-            attributes = (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, this.reconstituteTypeAttributes(originalAttributes));
-        }
-        const reconstituter = new TypeReconstituter(this, this.canonicalOrder, attributes, maybeForwardingRef, tref => {
-            if (this.debugPrint) {
-                this.changeDebugPrintIndent(-1);
-                console.log(`${this.debugPrintIndentation}reconstituted ${index} as ${(0, TypeGraph_1.typeRefIndex)(tref)}`);
-            }
-            if (maybeForwardingRef !== undefined) {
-                (0, Support_1.assert)(tref === maybeForwardingRef, "We didn't pass the forwarding ref");
-            }
-            const alreadyReconstitutedType = this.reconstitutedTypes.get(index);
-            if (alreadyReconstitutedType === undefined) {
-                this.reconstitutedTypes.set(index, tref);
-            }
-            else {
-                (0, Support_1.assert)(tref === alreadyReconstitutedType, "We reconstituted a type twice differently");
-            }
-        });
-        originalType.reconstitute(reconstituter, this.canonicalOrder);
-        return reconstituter.getResult();
-    }
-    /*
-    reconstituteTypeUnmodified(originalType: Type): TypeRef {
-        const reconstituter = new TypeReconstituter(
-            this,
-            this.alphabetizeProperties,
-            emptyTypeAttributes,
-            undefined,
-            () => {}
-        );
-        originalType.reconstitute(reconstituter);
-        return reconstituter.getResult();
-    }
-    */
-    // If the union of these type refs have been, or are supposed to be, reconstituted to
-    // one target type, return it.  Otherwise return undefined.
-    lookupTypeRefs(typeRefs, forwardingRef, replaceSet = true) {
-        this.assertTypeRefsToReconstitute(typeRefs, forwardingRef);
-        // Check whether we have already reconstituted them.  That means ensuring
-        // that they all have the same target type.
-        let maybeRef = this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(typeRefs[0]));
-        if (maybeRef !== undefined && maybeRef !== forwardingRef) {
-            let allEqual = true;
-            for (let i = 1; i < typeRefs.length; i++) {
-                if (this.reconstitutedTypes.get((0, TypeGraph_1.typeRefIndex)(typeRefs[i])) !== maybeRef) {
-                    allEqual = false;
-                    break;
-                }
-            }
-            if (allEqual) {
-                return this.forwardIfNecessary(forwardingRef, maybeRef);
-            }
-        }
-        // Has this been reconstituted as a set?
-        maybeRef = this._reconstitutedUnions.get(new Set(typeRefs));
-        if (maybeRef !== undefined && maybeRef !== forwardingRef) {
-            return this.forwardIfNecessary(forwardingRef, maybeRef);
-        }
-        // Is this set requested to be replaced?  If not, we're out of options.
-        const maybeSet = this._setsToReplaceByMember.get((0, TypeGraph_1.typeRefIndex)(typeRefs[0]));
-        if (maybeSet === undefined) {
-            return undefined;
-        }
-        for (let i = 1; i < typeRefs.length; i++) {
-            if (this._setsToReplaceByMember.get((0, TypeGraph_1.typeRefIndex)(typeRefs[i])) !== maybeSet) {
-                return undefined;
-            }
-        }
-        // Yes, this set is requested to be replaced, so do it.
-        if (!replaceSet)
-            return undefined;
-        return this.replaceSet(maybeSet, forwardingRef);
-    }
-}
-exports.GraphRewriteBuilder = GraphRewriteBuilder;

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

@@ -1,4 +0,0 @@
-import { TypeGraph } from "./TypeGraph";
-import { TargetLanguage } from "./TargetLanguage";
-import { RunContext } from "./Run";
-export declare function makeTransformations(ctx: RunContext, graph: TypeGraph, targetLanguage: TargetLanguage): TypeGraph;

package/dist/quicktype-core/MakeTransformations.js

@@ -1,193 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTransformations = void 0;
-const collection_utils_1 = require("collection-utils");
-const TypeGraph_1 = require("./TypeGraph");
-const Type_1 = require("./Type");
-const Support_1 = require("./support/Support");
-const Transformers_1 = require("./Transformers");
-const TypeAttributes_1 = require("./attributes/TypeAttributes");
-const StringTypes_1 = require("./attributes/StringTypes");
-const Constraints_1 = require("./attributes/Constraints");
-function transformationAttributes(graph, reconstitutedTargetType, transformer, debugPrintTransformations) {
-    const transformation = new Transformers_1.Transformation(graph, reconstitutedTargetType, transformer);
-    if (debugPrintTransformations) {
-        console.log(`transformation for ${(0, TypeGraph_1.typeRefIndex)(reconstitutedTargetType)}:`);
-        transformation.debugPrint();
-        console.log(`reverse:`);
-        transformation.reverse.debugPrint();
-    }
-    return Transformers_1.transformationTypeAttributeKind.makeAttributes(transformation);
-}
-function makeEnumTransformer(graph, enumType, stringType, continuation) {
-    const sortedCases = Array.from(enumType.cases).sort();
-    const caseTransformers = sortedCases.map(c => new Transformers_1.StringMatchTransformer(graph, stringType, new Transformers_1.StringProducerTransformer(graph, stringType, continuation, c), c));
-    return new Transformers_1.ChoiceTransformer(graph, stringType, caseTransformers);
-}
-function replaceUnion(union, builder, forwardingRef, transformedTypes, debugPrintTransformations) {
-    const graph = builder.typeGraph;
-    (0, Support_1.assert)(union.members.size > 0, "We can't have empty unions");
-    // Type attributes that we lost during reconstitution.
-    let additionalAttributes = TypeAttributes_1.emptyTypeAttributes;
-    function reconstituteMember(t) {
-        // Special handling for some transformed string type kinds: The type in
-        // the union must be the target type, so if one already exists, use that
-        // one, otherwise make a new one.
-        if ((0, Type_1.isPrimitiveStringTypeKind)(t.kind)) {
-            const targetTypeKind = (0, Type_1.targetTypeKindForTransformedStringTypeKind)(t.kind);
-            if (targetTypeKind !== undefined) {
-                const targetTypeMember = union.findMember(targetTypeKind);
-                additionalAttributes = (0, TypeAttributes_1.combineTypeAttributes)("union", additionalAttributes, t.getAttributes());
-                if (targetTypeMember !== undefined) {
-                    return builder.reconstituteType(targetTypeMember);
-                }
-                return builder.getPrimitiveType(targetTypeKind);
-            }
-        }
-        return builder.reconstituteType(t);
-    }
-    const reconstitutedMembersByKind = (0, collection_utils_1.mapMapEntries)(union.members.entries(), m => [m.kind, reconstituteMember(m)]);
-    const reconstitutedMemberSet = new Set(reconstitutedMembersByKind.values());
-    const haveUnion = reconstitutedMemberSet.size > 1;
-    if (!haveUnion) {
-        builder.setLostTypeAttributes();
-    }
-    const reconstitutedTargetType = haveUnion
-        ? builder.getUnionType(union.getAttributes(), reconstitutedMemberSet)
-        : (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(reconstitutedMemberSet));
-    function memberForKind(kind) {
-        return (0, Support_1.defined)(reconstitutedMembersByKind.get(kind));
-    }
-    function consumer(memberTypeRef) {
-        if (!haveUnion)
-            return undefined;
-        return new Transformers_1.UnionInstantiationTransformer(graph, memberTypeRef);
-    }
-    function transformerForKind(kind) {
-        const member = union.findMember(kind);
-        if (member === undefined)
-            return undefined;
-        const memberTypeRef = memberForKind(kind);
-        return new Transformers_1.DecodingTransformer(graph, memberTypeRef, consumer(memberTypeRef));
-    }
-    let maybeStringType = undefined;
-    function getStringType() {
-        if (maybeStringType === undefined) {
-            maybeStringType = builder.getStringType(TypeAttributes_1.emptyTypeAttributes, StringTypes_1.StringTypes.unrestricted);
-        }
-        return maybeStringType;
-    }
-    function transformerForStringType(t) {
-        const memberRef = memberForKind(t.kind);
-        if (t.kind === "string") {
-            const minMax = (0, Constraints_1.minMaxLengthForType)(t);
-            if (minMax === undefined) {
-                return consumer(memberRef);
-            }
-            const [min, max] = minMax;
-            return new Transformers_1.MinMaxLengthCheckTransformer(graph, getStringType(), consumer(memberRef), min, max);
-        }
-        else if (t instanceof Type_1.EnumType && transformedTypes.has(t)) {
-            return makeEnumTransformer(graph, t, getStringType(), consumer(memberRef));
-        }
-        else {
-            return new Transformers_1.ParseStringTransformer(graph, getStringType(), consumer(memberRef));
-        }
-    }
-    const stringTypes = (0, collection_utils_1.arraySortByInto)(Array.from(union.stringTypeMembers), t => t.kind);
-    let transformerForString;
-    if (stringTypes.length === 0) {
-        transformerForString = undefined;
-    }
-    else if (stringTypes.length === 1) {
-        const t = stringTypes[0];
-        transformerForString = new Transformers_1.DecodingTransformer(graph, getStringType(), transformerForStringType(t));
-    }
-    else {
-        transformerForString = new Transformers_1.DecodingTransformer(graph, getStringType(), new Transformers_1.ChoiceTransformer(graph, getStringType(), stringTypes.map(t => (0, Support_1.defined)(transformerForStringType(t)))));
-    }
-    const transformerForClass = transformerForKind("class");
-    const transformerForMap = transformerForKind("map");
-    (0, Support_1.assert)(transformerForClass === undefined || transformerForMap === undefined, "Can't have both class and map in a transformed union");
-    const transformerForObject = transformerForClass !== undefined ? transformerForClass : transformerForMap;
-    const transformer = new Transformers_1.DecodingChoiceTransformer(graph, builder.getPrimitiveType("any"), transformerForKind("null"), transformerForKind("integer"), transformerForKind("double"), transformerForKind("bool"), transformerForString, transformerForKind("array"), transformerForObject);
-    const attributes = transformationAttributes(graph, reconstitutedTargetType, transformer, debugPrintTransformations);
-    return builder.getPrimitiveType("any", (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, additionalAttributes), forwardingRef);
-}
-function replaceArray(arrayType, builder, forwardingRef, debugPrintTransformations) {
-    const anyType = builder.getPrimitiveType("any");
-    const anyArrayType = builder.getArrayType(TypeAttributes_1.emptyTypeAttributes, anyType);
-    const reconstitutedItems = builder.reconstituteType(arrayType.items);
-    const transformer = new Transformers_1.ArrayDecodingTransformer(builder.typeGraph, anyArrayType, undefined, reconstitutedItems, new Transformers_1.DecodingTransformer(builder.typeGraph, anyType, undefined));
-    const reconstitutedArray = builder.getArrayType(builder.reconstituteTypeAttributes(arrayType.getAttributes()), reconstitutedItems);
-    const attributes = transformationAttributes(builder.typeGraph, reconstitutedArray, transformer, debugPrintTransformations);
-    return builder.getArrayType(attributes, anyType, forwardingRef);
-}
-function replaceEnum(enumType, builder, forwardingRef, debugPrintTransformations) {
-    const stringType = builder.getStringType(TypeAttributes_1.emptyTypeAttributes, StringTypes_1.StringTypes.unrestricted);
-    const transformer = new Transformers_1.DecodingTransformer(builder.typeGraph, stringType, makeEnumTransformer(builder.typeGraph, enumType, stringType));
-    const reconstitutedEnum = builder.getEnumType(enumType.getAttributes(), enumType.cases);
-    const attributes = transformationAttributes(builder.typeGraph, reconstitutedEnum, transformer, debugPrintTransformations);
-    return builder.getStringType(attributes, StringTypes_1.StringTypes.unrestricted, forwardingRef);
-}
-function replaceNumber(t, builder, forwardingRef, debugPrintTransformations) {
-    const stringType = builder.getStringType(TypeAttributes_1.emptyTypeAttributes, StringTypes_1.StringTypes.unrestricted);
-    const [min, max] = (0, Support_1.defined)((0, Constraints_1.minMaxValueForType)(t));
-    const transformer = new Transformers_1.DecodingTransformer(builder.typeGraph, stringType, new Transformers_1.MinMaxValueTransformer(builder.typeGraph, stringType, undefined, min, max));
-    const reconstitutedAttributes = builder.reconstituteTypeAttributes(t.getAttributes());
-    const attributes = transformationAttributes(builder.typeGraph, builder.getPrimitiveType("double", reconstitutedAttributes, undefined), transformer, debugPrintTransformations);
-    return builder.getPrimitiveType("double", attributes, forwardingRef);
-}
-function replaceString(t, builder, forwardingRef, debugPrintTransformations) {
-    const [min, max] = (0, Support_1.defined)((0, Constraints_1.minMaxLengthForType)(t));
-    const reconstitutedAttributes = builder.reconstituteTypeAttributes(t.getAttributes());
-    const stringType = builder.getStringType(TypeAttributes_1.emptyTypeAttributes, StringTypes_1.StringTypes.unrestricted);
-    const transformer = new Transformers_1.DecodingTransformer(builder.typeGraph, stringType, new Transformers_1.MinMaxLengthCheckTransformer(builder.typeGraph, stringType, undefined, min, max));
-    const attributes = transformationAttributes(builder.typeGraph, builder.getStringType(reconstitutedAttributes, undefined), transformer, debugPrintTransformations);
-    return builder.getStringType(attributes, StringTypes_1.StringTypes.unrestricted, forwardingRef);
-}
-function replaceTransformedStringType(t, kind, builder, forwardingRef, debugPrintTransformations) {
-    const reconstitutedAttributes = builder.reconstituteTypeAttributes(t.getAttributes());
-    const targetTypeKind = (0, collection_utils_1.withDefault)((0, Type_1.targetTypeKindForTransformedStringTypeKind)(kind), kind);
-    const stringType = builder.getStringType(TypeAttributes_1.emptyTypeAttributes, StringTypes_1.StringTypes.unrestricted);
-    const transformer = new Transformers_1.DecodingTransformer(builder.typeGraph, stringType, new Transformers_1.ParseStringTransformer(builder.typeGraph, stringType, undefined));
-    const attributes = transformationAttributes(builder.typeGraph, builder.getPrimitiveType(targetTypeKind, reconstitutedAttributes), transformer, debugPrintTransformations);
-    return builder.getStringType(attributes, StringTypes_1.StringTypes.unrestricted, forwardingRef);
-}
-function makeTransformations(ctx, graph, targetLanguage) {
-    const transformedTypes = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), t => {
-        if (targetLanguage.needsTransformerForType(t))
-            return true;
-        if (!(t instanceof Type_1.UnionType))
-            return false;
-        const stringMembers = t.stringTypeMembers;
-        if (stringMembers.size <= 1)
-            return false;
-        return (0, collection_utils_1.iterableSome)(stringMembers, m => targetLanguage.needsTransformerForType(m));
-    });
-    function replace(setOfOneUnion, builder, forwardingRef) {
-        const t = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(setOfOneUnion));
-        if (t instanceof Type_1.UnionType) {
-            return replaceUnion(t, builder, forwardingRef, transformedTypes, ctx.debugPrintTransformations);
-        }
-        if (t instanceof Type_1.ArrayType) {
-            return replaceArray(t, builder, forwardingRef, ctx.debugPrintTransformations);
-        }
-        if (t instanceof Type_1.EnumType) {
-            return replaceEnum(t, builder, forwardingRef, ctx.debugPrintTransformations);
-        }
-        if (t.kind === "string") {
-            return replaceString(t, builder, forwardingRef, ctx.debugPrintTransformations);
-        }
-        if ((0, Type_1.isNumberTypeKind)(t.kind)) {
-            return replaceNumber(t, builder, forwardingRef, ctx.debugPrintTransformations);
-        }
-        if ((0, Type_1.isPrimitiveStringTypeKind)(t.kind)) {
-            return replaceTransformedStringType(t, t.kind, builder, forwardingRef, ctx.debugPrintTransformations);
-        }
-        return (0, Support_1.panic)(`Cannot make transformation for type ${t.kind}`);
-    }
-    const groups = Array.from(transformedTypes).map(t => [t]);
-    return graph.rewrite("make-transformations", ctx.stringTypeMapping, false, groups, ctx.debugPrintReconstitution, replace);
-}
-exports.makeTransformations = makeTransformations;

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

@@ -1,15 +0,0 @@
-export type SubTrie = number | null | Trie;
-export type Trie = {
-    count: number;
-    arr: SubTrie[];
-};
-export type MarkovChain = {
-    trie: Trie;
-    depth: number;
-};
-export declare function train(lines: string[], depth: number): MarkovChain;
-export declare function load(): MarkovChain;
-export declare function evaluateFull(mc: MarkovChain, word: string): [number, number[]];
-export declare function evaluate(mc: MarkovChain, word: string): number;
-export declare function generate(mc: MarkovChain, state: string, unseenWeight: number): string;
-export declare function test(): void;