quicktype 18.0.5 → 19.0.4

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

@@ -1,189 +0,0 @@
-"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 {
-    cases;
-    transformations;
-    static unrestricted = new StringTypes(undefined, new Set());
-    static fromCase(s, count) {
-        const caseMap = {};
-        caseMap[s] = count;
-        return new StringTypes(new Map([[s, count]]), new Set());
-    }
-    static fromCases(cases) {
-        const caseMap = {};
-        for (const s of cases) {
-            caseMap[s] = 1;
-        }
-        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;
-    }
-    union(othersArray, startIndex) {
-        if (this.cases === undefined)
-            return this;
-        const cases = new Map(this.cases);
-        const transformations = new Set(this.transformations);
-        for (let i = startIndex; i < othersArray.length; i++) {
-            const other = othersArray[i];
-            if (other.cases === undefined)
-                return other;
-            (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);
-    }
-    intersect(othersArray, startIndex) {
-        let cases = this.cases;
-        let transformations = this.transformations;
-        for (let i = startIndex; i < othersArray.length; i++) {
-            const other = othersArray[i];
-            if (cases === undefined) {
-                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 = (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 = (0, collection_utils_1.setIntersect)(transformations, other.transformations);
-        }
-        return new StringTypes(cases, transformations);
-    }
-    applyStringTypeMapping(mapping) {
-        if (!this.isRestricted)
-            return this;
-        const kinds = new Set();
-        for (const kind of this.transformations) {
-            const mapped = (0, TypeBuilder_1.stringTypeMappingGet)(mapping, kind);
-            if (mapped === "string")
-                return StringTypes.unrestricted;
-            kinds.add(mapped);
-        }
-        return new StringTypes(this.cases, new Set(kinds));
-    }
-    equals(other) {
-        if (!(other instanceof StringTypes))
-            return false;
-        return (0, collection_utils_1.areEqual)(this.cases, other.cases) && (0, collection_utils_1.areEqual)(this.transformations, other.transformations);
-    }
-    hashCode() {
-        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() {
-        const parts = [];
-        const enumCases = this.cases;
-        if (enumCases === undefined) {
-            parts.push("unrestricted");
-        }
-        else {
-            const firstKey = (0, collection_utils_1.iterableFirst)(enumCases.keys());
-            if (firstKey === undefined) {
-                parts.push("enum with no cases");
-            }
-            else {
-                parts.push(`${enumCases.size.toString()} enums: ${firstKey} (${enumCases.get(firstKey)}), ...`);
-            }
-        }
-        return parts.concat(Array.from(this.transformations)).join(",");
-    }
-}
-exports.StringTypes = StringTypes;
-class StringTypesTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
-    constructor() {
-        super("stringTypes");
-    }
-    get inIdentity() {
-        return true;
-    }
-    requiresUniqueIdentity(st) {
-        return st.cases !== undefined && st.cases.size > 0;
-    }
-    combine(arr) {
-        (0, Support_1.assert)(arr.length > 0);
-        return arr[0].union(arr, 1);
-    }
-    intersect(arr) {
-        (0, Support_1.assert)(arr.length > 0);
-        return arr[0].intersect(arr, 1);
-    }
-    makeInferred(_) {
-        return undefined;
-    }
-    stringify(st) {
-        return st.toString();
-    }
-}
-exports.stringTypesTypeAttributeKind = new StringTypesTypeAttributeKind();
-const INTEGER_STRING = /^(0|-?[1-9]\d*)$/;
-// We're restricting numbers to what's representable as 32 bit
-// signed integers, to be on the safe side of most languages.
-const MIN_INTEGER_STRING = 1 << 31;
-const MAX_INTEGER_STRING = -(MIN_INTEGER_STRING + 1);
-function isIntegerString(s) {
-    if (s.match(INTEGER_STRING) === null) {
-        return false;
-    }
-    const i = parseInt(s, 10);
-    return i >= MIN_INTEGER_STRING && i <= MAX_INTEGER_STRING;
-}
-const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-function isUUID(s) {
-    return s.match(UUID) !== null;
-}
-// FIXME: This is obviously not a complete URI regex.  The exclusion of
-// `{}` is a hack to make `github-events.json` work, which contains URLs
-// with those characters which ajv refuses to accept as `uri`.
-const URI = /^(https?|ftp):\/\/[^{}]+$/;
-function isURI(s) {
-    return s.match(URI) !== null;
-}
-/**
- * JSON inference calls this function to figure out whether a given string is to be
- * transformed into a higher level type.  Must return undefined if not, otherwise the
- * type kind of the transformed string type.
- *
- * @param s The string for which to determine the transformed string type kind.
- */
-function inferTransformedStringTypeKindForString(s, recognizer) {
-    if (s.length === 0 || "0123456789-abcdefth".indexOf(s[0]) < 0)
-        return undefined;
-    if (recognizer.isDate(s)) {
-        return "date";
-    }
-    else if (recognizer.isTime(s)) {
-        return "time";
-    }
-    else if (recognizer.isDateTime(s)) {
-        return "date-time";
-    }
-    else if (isIntegerString(s)) {
-        return "integer-string";
-    }
-    else if (s === "false" || s === "true") {
-        return "bool-string";
-    }
-    else if (isUUID(s)) {
-        return "uuid";
-    }
-    else if (isURI(s)) {
-        return "uri";
-    }
-    return undefined;
-}
-exports.inferTransformedStringTypeKindForString = inferTransformedStringTypeKindForString;

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

@@ -1,34 +0,0 @@
-import { Type, TypeKind } from "../Type";
-import { BaseGraphRewriteBuilder } from "../GraphRewriting";
-export declare class TypeAttributeKind<T> {
-    readonly name: string;
-    constructor(name: string);
-    appliesToTypeKind(kind: TypeKind): boolean;
-    combine(_attrs: T[]): T | undefined;
-    intersect(attrs: T[]): T | undefined;
-    makeInferred(_: T): T | undefined;
-    increaseDistance(attrs: T): T | undefined;
-    addToSchema(_schema: {
-        [name: string]: unknown;
-    }, _t: Type, _attrs: T): void;
-    children(_: T): ReadonlySet<Type>;
-    stringify(_: T): string | undefined;
-    get inIdentity(): boolean;
-    requiresUniqueIdentity(_: T): boolean;
-    reconstitute<TBuilder extends BaseGraphRewriteBuilder>(_builder: TBuilder, a: T): T;
-    makeAttributes(value: T): TypeAttributes;
-    tryGetInAttributes(a: TypeAttributes): T | undefined;
-    private setInAttributes;
-    modifyInAttributes(a: TypeAttributes, modify: (value: T | undefined) => T | undefined): TypeAttributes;
-    setDefaultInAttributes(a: TypeAttributes, makeDefault: () => T): TypeAttributes;
-    removeInAttributes(a: TypeAttributes): TypeAttributes;
-    equals(other: any): boolean;
-    hashCode(): number;
-}
-export type TypeAttributes = ReadonlyMap<TypeAttributeKind<any>, any>;
-export declare const emptyTypeAttributes: TypeAttributes;
-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;
-export declare function increaseTypeAttributesDistance(attr: TypeAttributes): TypeAttributes;

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

@@ -1,119 +0,0 @@
-"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;
-    }
-    appliesToTypeKind(kind) {
-        return kind !== "any";
-    }
-    combine(_attrs) {
-        return (0, Support_1.panic)(`Cannot combine type attribute ${this.name}`);
-    }
-    intersect(attrs) {
-        return this.combine(attrs);
-    }
-    makeInferred(_) {
-        return (0, Support_1.panic)(`Cannot make type attribute ${this.name} inferred`);
-    }
-    increaseDistance(attrs) {
-        return attrs;
-    }
-    addToSchema(_schema, _t, _attrs) {
-        return;
-    }
-    children(_) {
-        return new Set();
-    }
-    stringify(_) {
-        return undefined;
-    }
-    get inIdentity() {
-        return false;
-    }
-    requiresUniqueIdentity(_) {
-        return false;
-    }
-    reconstitute(_builder, a) {
-        return a;
-    }
-    makeAttributes(value) {
-        const kvps = [[this, value]];
-        return new Map(kvps);
-    }
-    tryGetInAttributes(a) {
-        return a.get(this);
-    }
-    setInAttributes(a, value) {
-        // FIXME: This is potentially super slow
-        return new Map(a).set(this, value);
-    }
-    modifyInAttributes(a, modify) {
-        const modified = modify(this.tryGetInAttributes(a));
-        if (modified === undefined) {
-            // FIXME: This is potentially super slow
-            const result = new Map(a);
-            result.delete(this);
-            return result;
-        }
-        return this.setInAttributes(a, modified);
-    }
-    setDefaultInAttributes(a, makeDefault) {
-        if (this.tryGetInAttributes(a) !== undefined)
-            return a;
-        return this.modifyInAttributes(a, makeDefault);
-    }
-    removeInAttributes(a) {
-        return (0, collection_utils_1.mapFilter)(a, (_, k) => k !== this);
-    }
-    equals(other) {
-        if (!(other instanceof TypeAttributeKind)) {
-            return false;
-        }
-        return this.name === other.name;
-    }
-    hashCode() {
-        return (0, collection_utils_1.hashString)(this.name);
-    }
-}
-exports.TypeAttributeKind = TypeAttributeKind;
-exports.emptyTypeAttributes = new Map();
-function combineTypeAttributes(combinationKind, firstOrArray, second) {
-    const union = combinationKind === "union";
-    let attributeArray;
-    if (Array.isArray(firstOrArray)) {
-        attributeArray = firstOrArray;
-    }
-    else {
-        if (second === undefined) {
-            return (0, Support_1.panic)("Must have on array or two attributes");
-        }
-        attributeArray = [firstOrArray, second];
-    }
-    const attributesByKind = (0, collection_utils_1.mapTranspose)(attributeArray);
-    function combine(attrs, kind) {
-        (0, Support_1.assert)(attrs.length > 0, "Cannot combine zero type attributes");
-        if (attrs.length === 1)
-            return attrs[0];
-        if (union) {
-            return kind.combine(attrs);
-        }
-        else {
-            return kind.intersect(attrs);
-        }
-    }
-    return (0, collection_utils_1.mapFilterMap)(attributesByKind, combine);
-}
-exports.combineTypeAttributes = combineTypeAttributes;
-function makeTypeAttributesInferred(attr) {
-    return (0, collection_utils_1.mapFilterMap)(attr, (value, kind) => kind.makeInferred(value));
-}
-exports.makeTypeAttributesInferred = makeTypeAttributesInferred;
-function increaseTypeAttributesDistance(attr) {
-    return (0, collection_utils_1.mapFilterMap)(attr, (value, kind) => kind.increaseDistance(value));
-}
-exports.increaseTypeAttributesDistance = increaseTypeAttributesDistance;

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

@@ -1,46 +0,0 @@
-import { TypeAttributeKind, TypeAttributes } from "./TypeAttributes";
-export declare function initTypeNames(): void;
-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);
-    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;
-    abstract singularize(): TypeNames;
-    abstract toString(): string;
-}
-export declare class RegularTypeNames extends TypeNames {
-    readonly names: ReadonlySet<string>;
-    private readonly _alternativeNames;
-    constructor(names: ReadonlySet<string>, _alternativeNames: ReadonlySet<string> | undefined, distance: number);
-    add(namesArray: TypeNames[], startIndex?: number): TypeNames;
-    clearInferred(): TypeNames;
-    get combinedName(): string;
-    get proposedNames(): ReadonlySet<string>;
-    makeInferred(): TypeNames;
-    singularize(): TypeNames;
-    toString(): string;
-}
-export declare class TooManyTypeNames extends TypeNames {
-    readonly names: ReadonlySet<string>;
-    constructor(distance: number, name?: string);
-    get combinedName(): string;
-    get proposedNames(): ReadonlySet<string>;
-    add(namesArray: TypeNames[], startIndex?: number): TypeNames;
-    clearInferred(): TypeNames;
-    makeInferred(): TypeNames;
-    singularize(): TypeNames;
-    toString(): string;
-}
-export declare const namesTypeAttributeKind: TypeAttributeKind<TypeNames>;
-export declare function modifyTypeNames(attributes: TypeAttributes, modifier: (tn: TypeNames | undefined) => TypeNames | undefined): TypeAttributes;
-export declare function singularizeTypeNames(attributes: TypeAttributes): TypeAttributes;
-export declare function makeNamesTypeAttributes(nameOrNames: NameOrNames, areNamesInferred?: boolean): TypeAttributes;

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

@@ -1,274 +0,0 @@
-"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 });
-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");
-const Strings_1 = require("../support/Strings");
-const Chance_1 = require("../support/Chance");
-let chance;
-let usedRandomNames;
-function initTypeNames() {
-    chance = new Chance_1.Chance(31415);
-    usedRandomNames = new Set();
-}
-exports.initTypeNames = initTypeNames;
-initTypeNames();
-function makeRandomName() {
-    for (;;) {
-        const name = `${chance.city()} ${chance.animal()}`;
-        if (usedRandomNames.has(name))
-            continue;
-        usedRandomNames.add(name);
-        return name;
-    }
-}
-// FIXME: In the case of overlapping prefixes and suffixes we will
-// produce a name that includes the overlap twice.  For example, for
-// 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 = (0, collection_utils_1.iterableFirst)(names);
-    if (originalFirst === undefined) {
-        return (0, Support_1.panic)("Named type has no names");
-    }
-    if (names.size === 1) {
-        return originalFirst;
-    }
-    const namesSet = (0, collection_utils_1.setMap)(names, s => (0, Strings_1.splitIntoWords)(s)
-        .map(w => w.word.toLowerCase())
-        .join("_"));
-    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 (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]) {
-                prefixLength = i;
-                break;
-            }
-        }
-        suffixLength = Math.min(suffixLength, n.length);
-        for (let i = 0; i < suffixLength; i++) {
-            if (first[first.length - i - 1] !== n[n.length - i - 1]) {
-                suffixLength = i;
-                break;
-            }
-        }
-    }
-    const prefix = prefixLength > 2 ? first.slice(0, prefixLength) : "";
-    const suffix = suffixLength > 2 ? first.slice(first.length - suffixLength) : "";
-    const combined = prefix + suffix;
-    if (combined.length > 2) {
-        return combined;
-    }
-    return first;
-}
-exports.tooManyNamesThreshold = 1000;
-class TypeNames {
-    distance;
-    static makeWithDistance(names, alternativeNames, distance) {
-        if (names.size >= exports.tooManyNamesThreshold) {
-            return new TooManyTypeNames(distance);
-        }
-        if (alternativeNames === undefined || alternativeNames.size > exports.tooManyNamesThreshold) {
-            alternativeNames = undefined;
-        }
-        return new RegularTypeNames(names, alternativeNames, distance);
-    }
-    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;
-        this._alternativeNames = _alternativeNames;
-    }
-    add(namesArray, startIndex = 0) {
-        let newNames = new Set(this.names);
-        let newDistance = this.distance;
-        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();
-                }
-                (0, collection_utils_1.setUnionInto)(newAlternativeNames, other._alternativeNames);
-            }
-            if (other.distance > newDistance)
-                continue;
-            if (!(other instanceof RegularTypeNames)) {
-                (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);
-            }
-            if (other.distance < newDistance) {
-                // The other one is closer, so take its names
-                newNames = new Set(other.names);
-                newDistance = other.distance;
-                newAlternativeNames = (0, collection_utils_1.definedMap)(other._alternativeNames, s => new Set(s));
-            }
-            else {
-                // Same distance, merge them
-                (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);
-    }
-    clearInferred() {
-        const newNames = this.areInferred ? new Set() : this.names;
-        return TypeNames.makeWithDistance(newNames, new Set(), this.distance);
-    }
-    get combinedName() {
-        return combineNames(this.names);
-    }
-    get proposedNames() {
-        const set = new Set([this.combinedName]);
-        if (this._alternativeNames === undefined) {
-            return set;
-        }
-        (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((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";
-        const names = `${inferred} ${Array.from(this.names).join(",")}`;
-        if (this._alternativeNames === undefined) {
-            return names;
-        }
-        return `${names} (${Array.from(this._alternativeNames).join(",")})`;
-    }
-}
-exports.RegularTypeNames = RegularTypeNames;
-class TooManyTypeNames extends TypeNames {
-    names;
-    constructor(distance, name) {
-        super(distance);
-        if (name === undefined) {
-            name = makeRandomName();
-        }
-        this.names = new Set([name]);
-    }
-    get combinedName() {
-        return (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(this.names));
-    }
-    get proposedNames() {
-        return this.names;
-    }
-    add(namesArray, startIndex = 0) {
-        if (!this.areInferred)
-            return this;
-        for (let i = startIndex; i < namesArray.length; i++) {
-            const other = namesArray[i];
-            if (other.distance < this.distance) {
-                return other.add(namesArray, i + 1);
-            }
-        }
-        return this;
-    }
-    clearInferred() {
-        if (!this.areInferred) {
-            return this;
-        }
-        return TypeNames.makeWithDistance(new Set(), new Set(), this.distance);
-    }
-    makeInferred() {
-        return new TooManyTypeNames(this.distance + 1, (0, collection_utils_1.iterableFirst)(this.names));
-    }
-    singularize() {
-        return this;
-    }
-    toString() {
-        return `too many ${this.combinedName}`;
-    }
-}
-exports.TooManyTypeNames = TooManyTypeNames;
-class TypeNamesTypeAttributeKind extends TypeAttributes_1.TypeAttributeKind {
-    constructor() {
-        super("names");
-    }
-    combine(namesArray) {
-        (0, Support_1.assert)(namesArray.length > 0, "Can't combine zero type names");
-        return namesArray[0].add(namesArray, 1);
-    }
-    makeInferred(tn) {
-        return tn.makeInferred();
-    }
-    increaseDistance(tn) {
-        return tn.makeInferred();
-    }
-    stringify(tn) {
-        return tn.toString();
-    }
-}
-exports.namesTypeAttributeKind = new TypeNamesTypeAttributeKind();
-function modifyTypeNames(attributes, modifier) {
-    return exports.namesTypeAttributeKind.modifyInAttributes(attributes, modifier);
-}
-exports.modifyTypeNames = modifyTypeNames;
-function singularizeTypeNames(attributes) {
-    return modifyTypeNames(attributes, maybeNames => {
-        if (maybeNames === undefined)
-            return undefined;
-        return maybeNames.singularize();
-    });
-}
-exports.singularizeTypeNames = singularizeTypeNames;
-function makeNamesTypeAttributes(nameOrNames, areNamesInferred) {
-    let typeNames;
-    if (typeof nameOrNames === "string") {
-        typeNames = TypeNames.make(new Set([nameOrNames]), new Set(), (0, Support_1.defined)(areNamesInferred));
-    }
-    else {
-        typeNames = nameOrNames;
-    }
-    return exports.namesTypeAttributeKind.makeAttributes(typeNames);
-}
-exports.makeNamesTypeAttributes = makeNamesTypeAttributes;

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

@@ -1,8 +0,0 @@
-import { TypeAttributeKind, TypeAttributes } from "./TypeAttributes";
-import { JSONSchemaType, JSONSchemaAttributes, Ref } from "../input/JSONSchemaInput";
-import { JSONSchema } from "../input/JSONSchemaStore";
-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;
-export {};