quicktype-core 7.0.34 → 7.0.36

package/dist/Annotation.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nullTypeIssueAnnotation = exports.anyTypeIssueAnnotation = exports.IssueAnnotationData = exports.AnnotationData = void 0;
 class AnnotationData {
 }
 exports.AnnotationData = AnnotationData;

package/dist/ConvenienceRenderer.d.ts

@@ -7,7 +7,7 @@ import { Transformation } from "./Transformers";
 import { TargetLanguage } from "./TargetLanguage";
 export declare const topLevelNameOrder = 1;
 export declare const inferredNameOrder = 30;
-export type ForbiddenWordsInfo = {
+export declare type ForbiddenWordsInfo = {
     names: (Name | string)[];
     includeGlobalForbidden: boolean;
 };
@@ -34,7 +34,7 @@ export declare abstract class ConvenienceRenderer extends Renderer {
     private _cycleBreakerTypes?;
     private _alphabetizeProperties;
     constructor(targetLanguage: TargetLanguage, renderContext: RenderContext);
-    get topLevels(): ReadonlyMap<string, Type>;
+    readonly topLevels: ReadonlyMap<string, Type>;
     /**
      * Return an array of strings which are not allowed as names in the global
      * namespace.  Since names of generated types are in the global namespace,
@@ -65,13 +65,13 @@ export declare abstract class ConvenienceRenderer extends Renderer {
     protected abstract emitSourceStructure(givenOutputFilename: string): void;
     protected makeNameForTransformation(_xf: Transformation, _typeName: Name | undefined): Name | undefined;
     protected namedTypeToNameForTopLevel(type: Type): Type | undefined;
-    protected get unionMembersInGlobalNamespace(): boolean;
-    protected get enumCasesInGlobalNamespace(): boolean;
-    protected get needsTypeDeclarationBeforeUse(): boolean;
+    protected readonly unionMembersInGlobalNamespace: boolean;
+    protected readonly enumCasesInGlobalNamespace: boolean;
+    protected readonly needsTypeDeclarationBeforeUse: boolean;
     protected canBeForwardDeclared(_t: Type): boolean;
     protected unionNeedsName(u: UnionType): boolean;
-    private get globalNamespace();
-    private get nameStoreView();
+    private readonly globalNamespace;
+    private readonly nameStoreView;
     protected descriptionForType(t: Type): string[] | undefined;
     protected descriptionForClassProperty(o: ObjectType, name: string): string[] | undefined;
     protected setUpNaming(): ReadonlySet<Namespace>;
@@ -81,7 +81,7 @@ export declare abstract class ConvenienceRenderer extends Renderer {
     private makeNameForType;
     protected makeNameForNamedType(t: Type): Name;
     private addNameForNamedType;
-    protected get typesWithNamedTransformations(): ReadonlyMap<Type, Name>;
+    protected readonly typesWithNamedTransformations: ReadonlyMap<Type, Name>;
     protected nameForTransformation(t: Type): Name | undefined;
     private addNameForTransformation;
     private processForbiddenWordsInfo;
@@ -93,14 +93,14 @@ export declare abstract class ConvenienceRenderer extends Renderer {
     protected makeNameForEnumCase(e: EnumType, _enumName: Name, caseName: string, assignedName: string | undefined): Name;
     private addEnumCaseNames;
     private childrenOfType;
-    protected get namedUnions(): ReadonlySet<UnionType>;
-    protected get haveNamedUnions(): boolean;
-    protected get haveNamedTypes(): boolean;
-    protected get haveUnions(): boolean;
-    protected get haveMaps(): boolean;
-    protected get haveOptionalProperties(): boolean;
-    protected get enums(): ReadonlySet<EnumType>;
-    protected get haveEnums(): boolean;
+    protected readonly namedUnions: ReadonlySet<UnionType>;
+    protected readonly haveNamedUnions: boolean;
+    protected readonly haveNamedTypes: boolean;
+    protected readonly haveUnions: boolean;
+    protected readonly haveMaps: boolean;
+    protected readonly haveOptionalProperties: boolean;
+    protected readonly enums: ReadonlySet<EnumType>;
+    protected readonly haveEnums: boolean;
     protected proposedUnionMemberNameForTypeKind(_kind: TypeKind): string | null;
     protected proposeUnionMemberName(_u: UnionType, _unionName: Name, fieldType: Type, lookup: (n: Name) => string): string;
     protected nameForNamedType(t: Type): Name;
@@ -127,7 +127,7 @@ export declare abstract class ConvenienceRenderer extends Renderer {
     protected forEachUniqueUnion<T>(blankLocations: BlankLineConfig, uniqueValue: (u: UnionType) => T, f: (firstUnion: UnionType, value: T, position: ForEachPosition) => void): void;
     protected forEachNamedType(blankLocations: BlankLineConfig, objectFunc: ((c: ClassType, className: Name, position: ForEachPosition) => void) | ((o: ObjectType, objectName: Name, position: ForEachPosition) => void), enumFunc: (e: EnumType, enumName: Name, position: ForEachPosition) => void, unionFunc: (u: UnionType, unionName: Name, position: ForEachPosition) => void): void;
     protected sourcelikeToString(src: Sourcelike): string;
-    protected get commentLineStart(): string;
+    protected readonly commentLineStart: string;
     protected emitCommentLines(lines: Sourcelike[], lineStart?: string, beforeLine?: string, afterLine?: string, firstLineStart?: string): void;
     protected emitDescription(description: Sourcelike[] | undefined): void;
     protected emitDescriptionBlock(lines: Sourcelike[]): void;

package/dist/ConvenienceRenderer.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConvenienceRenderer = exports.inferredNameOrder = exports.topLevelNameOrder = void 0;
 const collection_utils_1 = require("collection-utils");
 const Type_1 = require("./Type");
 const TypeUtils_1 = require("./TypeUtils");
@@ -85,7 +84,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         return undefined;
     }
     namedTypeToNameForTopLevel(type) {
-        if ((0, TypeUtils_1.isNamedType)(type)) {
+        if (TypeUtils_1.isNamedType(type)) {
             return type;
         }
         return undefined;
@@ -100,16 +99,16 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         return false;
     }
     canBeForwardDeclared(_t) {
-        return (0, Support_1.panic)("If needsTypeDeclarationBeforeUse returns true, canBeForwardDeclared must be implemented");
+        return Support_1.panic("If needsTypeDeclarationBeforeUse returns true, canBeForwardDeclared must be implemented");
     }
     unionNeedsName(u) {
-        return (0, TypeUtils_1.nullableFromUnion)(u) === null;
+        return TypeUtils_1.nullableFromUnion(u) === null;
     }
     get globalNamespace() {
-        return (0, Support_1.defined)(this._globalNamespace);
+        return Support_1.defined(this._globalNamespace);
     }
     get nameStoreView() {
-        return (0, Support_1.defined)(this._nameStoreView);
+        return Support_1.defined(this._nameStoreView);
     }
     descriptionForType(t) {
         let description = this.typeGraph.attributeStore.tryGet(Description_1.descriptionTypeAttributeKind, t);
@@ -130,11 +129,11 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         this._namedTypeNamer = this.makeNamedTypeNamer();
         this._unionMemberNamer = this.makeUnionMemberNamer();
         this._enumCaseNamer = this.makeEnumCaseNamer();
-        this._globalForbiddenNamespace = (0, Naming_1.keywordNamespace)("forbidden", this.forbiddenNamesForGlobalNamespace());
+        this._globalForbiddenNamespace = Naming_1.keywordNamespace("forbidden", this.forbiddenNamesForGlobalNamespace());
         this._otherForbiddenNamespaces = new Map();
         this._globalNamespace = new Naming_1.Namespace("global", undefined, [this._globalForbiddenNamespace], []);
         const { objects, enums, unions } = this.typeGraph.allNamedTypesSeparated();
-        const namedUnions = (0, collection_utils_1.setFilter)(unions, u => this.unionNeedsName(u));
+        const namedUnions = collection_utils_1.setFilter(unions, u => this.unionNeedsName(u));
         for (const [name, t] of this.topLevels) {
             this.nameStoreView.setForTopLevel(name, this.addNameForTopLevel(t, name));
         }
@@ -153,7 +152,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         for (const t of this.typeGraph.allTypesUnordered()) {
             this.addNameForTransformation(t);
         }
-        return (0, collection_utils_1.setUnion)([this._globalForbiddenNamespace, this._globalNamespace], this._otherForbiddenNamespaces.values());
+        return collection_utils_1.setUnion([this._globalForbiddenNamespace, this._globalNamespace], this._otherForbiddenNamespaces.values());
     }
     addDependenciesForNamedType(type, named) {
         const dependencyNames = this.makeNamedTypeDependencyNames(type, named);
@@ -162,7 +161,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         }
     }
     makeNameForTopLevel(_t, givenName, _maybeNamedType) {
-        return new Naming_1.SimpleName([givenName], (0, Support_1.defined)(this._namedTypeNamer), exports.topLevelNameOrder);
+        return new Naming_1.SimpleName([givenName], Support_1.defined(this._namedTypeNamer), exports.topLevelNameOrder);
     }
     addNameForTopLevel(type, givenName) {
         const maybeNamedType = this.namedTypeToNameForTopLevel(type);
@@ -184,7 +183,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         return new Naming_1.SimpleName(names.proposedNames, namer, order);
     }
     makeNameForNamedType(t) {
-        return this.makeNameForType(t, (0, Support_1.defined)(this._namedTypeNamer), givenNameOrder, exports.inferredNameOrder);
+        return this.makeNameForType(t, Support_1.defined(this._namedTypeNamer), givenNameOrder, exports.inferredNameOrder);
     }
     addNameForNamedType(type) {
         const existing = this.nameStoreView.tryGet(type);
@@ -196,28 +195,28 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         return name;
     }
     get typesWithNamedTransformations() {
-        return (0, Support_1.defined)(this._namesForTransformations);
+        return Support_1.defined(this._namesForTransformations);
     }
     nameForTransformation(t) {
-        const xf = (0, Transformers_1.transformationForType)(t);
+        const xf = Transformers_1.transformationForType(t);
         if (xf === undefined)
             return undefined;
-        const name = (0, Support_1.defined)(this._namesForTransformations).get(t);
+        const name = Support_1.defined(this._namesForTransformations).get(t);
         if (name === undefined) {
-            return (0, Support_1.panic)("No name for transformation");
+            return Support_1.panic("No name for transformation");
         }
         return name;
     }
     addNameForTransformation(t) {
-        const xf = (0, Transformers_1.transformationForType)(t);
+        const xf = Transformers_1.transformationForType(t);
         if (xf === undefined)
             return;
-        (0, Support_1.assert)((0, Support_1.defined)(this._namesForTransformations).get(t) === undefined, "Tried to give two names to the same transformation");
+        Support_1.assert(Support_1.defined(this._namesForTransformations).get(t) === undefined, "Tried to give two names to the same transformation");
         const name = this.makeNameForTransformation(xf, this.nameStoreView.tryGet(xf.targetType));
         if (name === undefined)
             return;
         this.globalNamespace.add(name);
-        (0, Support_1.defined)(this._namesForTransformations).set(t, name);
+        Support_1.defined(this._namesForTransformations).set(t, name);
     }
     processForbiddenWordsInfo(info, namespaceName) {
         const forbiddenNames = [];
@@ -230,14 +229,14 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
                 forbiddenNames.push(nameOrString);
             }
         }
-        let namespace = (0, Support_1.defined)(this._otherForbiddenNamespaces).get(namespaceName);
+        let namespace = Support_1.defined(this._otherForbiddenNamespaces).get(namespaceName);
         if (forbiddenStrings.length > 0 && namespace === undefined) {
-            namespace = (0, Naming_1.keywordNamespace)(namespaceName, forbiddenStrings);
-            this._otherForbiddenNamespaces = (0, Support_1.defined)(this._otherForbiddenNamespaces).set(namespaceName, namespace);
+            namespace = Naming_1.keywordNamespace(namespaceName, forbiddenStrings);
+            this._otherForbiddenNamespaces = Support_1.defined(this._otherForbiddenNamespaces).set(namespaceName, namespace);
         }
         let forbiddenNamespaces = new Set();
         if (info.includeGlobalForbidden) {
-            forbiddenNamespaces = forbiddenNamespaces.add((0, Support_1.defined)(this._globalForbiddenNamespace));
+            forbiddenNamespaces = forbiddenNamespaces.add(Support_1.defined(this._globalForbiddenNamespace));
         }
         if (namespace !== undefined) {
             forbiddenNamespaces = forbiddenNamespaces.add(namespace);
@@ -268,12 +267,12 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
     addPropertyNames(o, className) {
         const { forbiddenNames, forbiddenNamespaces } = this.processForbiddenWordsInfo(this.forbiddenForObjectProperties(o, className), "forbidden-for-properties");
         let ns;
-        const accessorNames = (0, AccessorNames_1.objectPropertyNames)(o, this.targetLanguage.name);
-        const names = (0, collection_utils_1.mapFilterMap)(o.getSortedProperties(), (p, jsonName) => {
-            const [assignedName, isFixed] = (0, AccessorNames_1.getAccessorName)(accessorNames, jsonName);
+        const accessorNames = AccessorNames_1.objectPropertyNames(o, this.targetLanguage.name);
+        const names = collection_utils_1.mapFilterMap(o.getSortedProperties(), (p, jsonName) => {
+            const [assignedName, isFixed] = AccessorNames_1.getAccessorName(accessorNames, jsonName);
             let name;
             if (isFixed) {
-                name = new Naming_1.FixedName((0, Support_1.defined)(assignedName));
+                name = new Naming_1.FixedName(Support_1.defined(assignedName));
             }
             else {
                 name = this.makeNameForProperty(o, className, p, jsonName, assignedName);
@@ -289,14 +288,14 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
             }
             return name;
         });
-        (0, Support_1.defined)(this._propertyNamesStoreView).set(o, names);
+        Support_1.defined(this._propertyNamesStoreView).set(o, names);
     }
     makeNameForUnionMember(u, unionName, t) {
-        const [assignedName, isFixed] = (0, AccessorNames_1.unionMemberName)(u, t, this.targetLanguage.name);
+        const [assignedName, isFixed] = AccessorNames_1.unionMemberName(u, t, this.targetLanguage.name);
         if (isFixed) {
-            return new Naming_1.FixedName((0, Support_1.defined)(assignedName));
+            return new Naming_1.FixedName(Support_1.defined(assignedName));
         }
-        return new Naming_1.DependencyName((0, Support_1.nonNull)(this._unionMemberNamer), unionMemberNameOrder, lookup => {
+        return new Naming_1.DependencyName(Support_1.nonNull(this._unionMemberNamer), unionMemberNameOrder, lookup => {
             if (assignedName !== undefined)
                 return assignedName;
             return this.proposeUnionMemberName(u, unionName, t, lookup);
@@ -316,10 +315,10 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         }
         let names = new Map();
         for (const t of u.members) {
-            const name = this.makeNameForUnionMember(u, unionName, (0, Transformers_1.followTargetType)(t));
+            const name = this.makeNameForUnionMember(u, unionName, Transformers_1.followTargetType(t));
             names.set(t, ns.add(name));
         }
-        (0, Support_1.defined)(this._memberNamesStoreView).set(u, names);
+        Support_1.defined(this._memberNamesStoreView).set(u, names);
     }
     makeNameForEnumCase(e, _enumName, caseName, assignedName) {
         // FIXME: See the FIXME in `makeNameForProperty`.  We do have global
@@ -327,7 +326,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         const alternative = `${e.getCombinedName()}_${caseName}`;
         const order = assignedName === undefined ? enumCaseNameOrder : assignedEnumCaseNameOrder;
         const names = assignedName === undefined ? [caseName, alternative] : [assignedName];
-        return new Naming_1.SimpleName(names, (0, Support_1.nonNull)(this._enumCaseNamer), order);
+        return new Naming_1.SimpleName(names, Support_1.nonNull(this._enumCaseNamer), order);
     }
     // FIXME: this is very similar to addPropertyNameds and addUnionMemberNames
     addEnumCaseNames(e, enumName) {
@@ -342,56 +341,56 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
             ns = new Naming_1.Namespace(e.getCombinedName(), this.globalNamespace, forbiddenNamespaces, forbiddenNames);
         }
         let names = new Map();
-        const accessorNames = (0, AccessorNames_1.enumCaseNames)(e, this.targetLanguage.name);
+        const accessorNames = AccessorNames_1.enumCaseNames(e, this.targetLanguage.name);
         for (const caseName of e.cases) {
-            const [assignedName, isFixed] = (0, AccessorNames_1.getAccessorName)(accessorNames, caseName);
+            const [assignedName, isFixed] = AccessorNames_1.getAccessorName(accessorNames, caseName);
             let name;
             if (isFixed) {
-                name = new Naming_1.FixedName((0, Support_1.defined)(assignedName));
+                name = new Naming_1.FixedName(Support_1.defined(assignedName));
             }
             else {
                 name = this.makeNameForEnumCase(e, enumName, caseName, assignedName);
             }
             names.set(caseName, ns.add(name));
         }
-        (0, Support_1.defined)(this._caseNamesStoreView).set(e, names);
+        Support_1.defined(this._caseNamesStoreView).set(e, names);
     }
     childrenOfType(t) {
         const names = this.names;
         if (t instanceof Type_1.ClassType) {
-            const propertyNameds = (0, Support_1.defined)(this._propertyNamesStoreView).get(t);
-            const filteredMap = (0, collection_utils_1.mapFilterMap)(t.getProperties(), (p, n) => {
+            const propertyNameds = Support_1.defined(this._propertyNamesStoreView).get(t);
+            const filteredMap = collection_utils_1.mapFilterMap(t.getProperties(), (p, n) => {
                 if (propertyNameds.get(n) === undefined)
                     return undefined;
                 return p.type;
             });
-            const sortedMap = (0, collection_utils_1.mapSortBy)(filteredMap, (_, n) => (0, Support_1.defined)(names.get((0, Support_1.defined)(propertyNameds.get(n)))));
+            const sortedMap = collection_utils_1.mapSortBy(filteredMap, (_, n) => Support_1.defined(names.get(Support_1.defined(propertyNameds.get(n)))));
             return new Set(sortedMap.values());
         }
         return t.getChildren();
     }
     get namedUnions() {
-        return (0, Support_1.defined)(this._namedUnions);
+        return Support_1.defined(this._namedUnions);
     }
     get haveNamedUnions() {
         return this.namedUnions.size > 0;
     }
     get haveNamedTypes() {
-        return (0, Support_1.defined)(this._namedTypes).length > 0;
+        return Support_1.defined(this._namedTypes).length > 0;
     }
     get haveUnions() {
-        return (0, Support_1.defined)(this._haveUnions);
+        return Support_1.defined(this._haveUnions);
     }
     get haveMaps() {
-        return (0, Support_1.defined)(this._haveMaps);
+        return Support_1.defined(this._haveMaps);
     }
     get haveOptionalProperties() {
-        return (0, Support_1.defined)(this._haveOptionalProperties);
+        return Support_1.defined(this._haveOptionalProperties);
     }
     // FIXME: Inconsistently named, though technically correct.  Right now all enums are named,
     // but this should really be called `namedEnums`.
     get enums() {
-        return (0, Support_1.defined)(this._namedEnums);
+        return Support_1.defined(this._namedEnums);
     }
     get haveEnums() {
         return this.enums.size > 0;
@@ -404,10 +403,10 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         if (simpleName !== null) {
             return simpleName;
         }
-        const typeNameForUnionMember = (t) => (0, TypeUtils_1.matchTypeExhaustive)(t, _noneType => {
-            return (0, Support_1.panic)("none type should have been replaced");
+        const typeNameForUnionMember = (t) => TypeUtils_1.matchTypeExhaustive(t, _noneType => {
+            return Support_1.panic("none type should have been replaced");
         }, _anyType => "anything", _nullType => "null", _boolType => "bool", _integerType => "integer", _doubleType => "double", _stringType => "string", arrayType => typeNameForUnionMember(arrayType.items) + "_array", classType => lookup(this.nameForNamedType(classType)), mapType => typeNameForUnionMember(mapType.values) + "_map", objectType => {
-            (0, Support_1.assert)(this.targetLanguage.supportsFullObjectType, "Object type should have been replaced in `replaceObjectType`");
+            Support_1.assert(this.targetLanguage.supportsFullObjectType, "Object type should have been replaced in `replaceObjectType`");
             return lookup(this.nameForNamedType(objectType));
         }, _enumType => "enum", _unionType => "union", transformedType => transformedType.kind.replace("-", "_"));
         return typeNameForUnionMember(fieldType);
@@ -416,24 +415,24 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         return this.nameStoreView.get(t);
     }
     isForwardDeclaredType(t) {
-        return (0, Support_1.defined)(this._declarationIR).forwardedTypes.has(t);
+        return Support_1.defined(this._declarationIR).forwardedTypes.has(t);
     }
     isImplicitCycleBreaker(_t) {
-        return (0, Support_1.panic)("A renderer that invokes isCycleBreakerType must implement isImplicitCycleBreaker");
+        return Support_1.panic("A renderer that invokes isCycleBreakerType must implement isImplicitCycleBreaker");
     }
     canBreakCycles(_t) {
         return true;
     }
     isCycleBreakerType(t) {
         if (this._cycleBreakerTypes === undefined) {
-            this._cycleBreakerTypes = (0, DeclarationIR_1.cycleBreakerTypesForGraph)(this.typeGraph, s => this.isImplicitCycleBreaker(s), s => this.canBreakCycles(s));
+            this._cycleBreakerTypes = DeclarationIR_1.cycleBreakerTypesForGraph(this.typeGraph, s => this.isImplicitCycleBreaker(s), s => this.canBreakCycles(s));
         }
         return this._cycleBreakerTypes.has(t);
     }
     forEachTopLevel(blankLocations, f, predicate) {
         let topLevels;
         if (predicate !== undefined) {
-            topLevels = (0, collection_utils_1.mapFilter)(this.topLevels, predicate);
+            topLevels = collection_utils_1.mapFilter(this.topLevels, predicate);
         }
         else {
             topLevels = this.topLevels;
@@ -441,7 +440,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         return this.forEachWithBlankLines(topLevels, blankLocations, (t, name, pos) => f(t, this.nameStoreView.getForTopLevel(name), pos));
     }
     forEachDeclaration(blankLocations, f) {
-        this.forEachWithBlankLines((0, collection_utils_1.iterableEnumerate)((0, Support_1.defined)(this._declarationIR).declarations), blankLocations, (decl, _, pos) => f(decl, pos));
+        this.forEachWithBlankLines(collection_utils_1.iterableEnumerate(Support_1.defined(this._declarationIR).declarations), blankLocations, (decl, _, pos) => f(decl, pos));
     }
     setAlphabetizeProperties(value) {
         this._alphabetizeProperties = value;
@@ -451,14 +450,14 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
     }
     // Returns the number of properties defined for the specified object type.
     propertyCount(o) {
-        const propertyNames = (0, Support_1.defined)(this._propertyNamesStoreView).get(o);
+        const propertyNames = Support_1.defined(this._propertyNamesStoreView).get(o);
         return propertyNames.size;
     }
     sortClassProperties(properties, propertyNames) {
         if (this._alphabetizeProperties) {
-            return (0, collection_utils_1.mapSortBy)(properties, (_p, jsonName) => {
-                const name = (0, Support_1.defined)(propertyNames.get(jsonName));
-                return (0, Support_1.defined)(this.names.get(name));
+            return collection_utils_1.mapSortBy(properties, (_p, jsonName) => {
+                const name = Support_1.defined(propertyNames.get(jsonName));
+                return Support_1.defined(this.names.get(name));
             });
         }
         else {
@@ -466,43 +465,43 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         }
     }
     forEachClassProperty(o, blankLocations, f) {
-        const propertyNames = (0, Support_1.defined)(this._propertyNamesStoreView).get(o);
+        const propertyNames = Support_1.defined(this._propertyNamesStoreView).get(o);
         const sortedProperties = this.sortClassProperties(o.getProperties(), propertyNames);
         this.forEachWithBlankLines(sortedProperties, blankLocations, (p, jsonName, pos) => {
-            const name = (0, Support_1.defined)(propertyNames.get(jsonName));
+            const name = Support_1.defined(propertyNames.get(jsonName));
             f(name, jsonName, p, pos);
         });
     }
     nameForUnionMember(u, t) {
-        return (0, Support_1.defined)((0, Support_1.defined)(this._memberNamesStoreView).get(u).get(t));
+        return Support_1.defined(Support_1.defined(this._memberNamesStoreView).get(u).get(t));
     }
     nameForEnumCase(e, caseName) {
-        const caseNames = (0, Support_1.defined)(this._caseNamesStoreView).get(e);
-        return (0, Support_1.defined)(caseNames.get(caseName));
+        const caseNames = Support_1.defined(this._caseNamesStoreView).get(e);
+        return Support_1.defined(caseNames.get(caseName));
     }
     forEachUnionMember(u, members, blankLocations, sortOrder, f) {
         const iterateMembers = members === null ? u.members : members;
         if (sortOrder === null) {
-            sortOrder = n => (0, Support_1.defined)(this.names.get(n));
+            sortOrder = n => Support_1.defined(this.names.get(n));
         }
-        const memberNames = (0, collection_utils_1.mapFilter)((0, Support_1.defined)(this._memberNamesStoreView).get(u), (_, t) => iterateMembers.has(t));
-        const sortedMemberNames = (0, collection_utils_1.mapSortBy)(memberNames, sortOrder);
+        const memberNames = collection_utils_1.mapFilter(Support_1.defined(this._memberNamesStoreView).get(u), (_, t) => iterateMembers.has(t));
+        const sortedMemberNames = collection_utils_1.mapSortBy(memberNames, sortOrder);
         this.forEachWithBlankLines(sortedMemberNames, blankLocations, f);
     }
     forEachEnumCase(e, blankLocations, f) {
-        const caseNames = (0, Support_1.defined)(this._caseNamesStoreView).get(e);
-        const sortedCaseNames = (0, collection_utils_1.mapSortBy)(caseNames, n => (0, Support_1.defined)(this.names.get(n)));
+        const caseNames = Support_1.defined(this._caseNamesStoreView).get(e);
+        const sortedCaseNames = collection_utils_1.mapSortBy(caseNames, n => Support_1.defined(this.names.get(n)));
         this.forEachWithBlankLines(sortedCaseNames, blankLocations, f);
     }
     forEachTransformation(blankLocations, f) {
-        this.forEachWithBlankLines((0, Support_1.defined)(this._namesForTransformations), blankLocations, f);
+        this.forEachWithBlankLines(Support_1.defined(this._namesForTransformations), blankLocations, f);
     }
     forEachSpecificNamedType(blankLocations, types, f) {
         this.forEachWithBlankLines(types, blankLocations, (t, _, pos) => f(t, this.nameForNamedType(t), pos));
     }
     forEachObject(blankLocations, f) {
         // FIXME: This is ugly.
-        this.forEachSpecificNamedType(blankLocations, (0, Support_1.defined)(this._namedObjects).entries(), f);
+        this.forEachSpecificNamedType(blankLocations, Support_1.defined(this._namedObjects).entries(), f);
     }
     forEachEnum(blankLocations, f) {
         this.forEachSpecificNamedType(blankLocations, this.enums.entries(), f);
@@ -521,7 +520,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         this.forEachWithBlankLines(firstUnionByValue, blankLocations, f);
     }
     forEachNamedType(blankLocations, objectFunc, enumFunc, unionFunc) {
-        this.forEachWithBlankLines((0, Support_1.defined)(this._namedTypes).entries(), blankLocations, (t, _, pos) => {
+        this.forEachWithBlankLines(Support_1.defined(this._namedTypes).entries(), blankLocations, (t, _, pos) => {
             const name = this.nameForNamedType(t);
             if (t instanceof Type_1.ObjectType) {
                 // FIXME: This is ugly.  We can't runtime check that the function
@@ -535,7 +534,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
                 unionFunc(t, name, pos);
             }
             else {
-                return (0, Support_1.panic)("Named type that's neither a class nor union");
+                return Support_1.panic("Named type that's neither a class nor union");
             }
         });
     }
@@ -543,7 +542,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
     // code.  If you need to modify a Name, for example to change its casing,
     // use `modifySource`.
     sourcelikeToString(src) {
-        return (0, Source_1.serializeRenderResult)((0, Source_1.sourcelikeToSource)(src), this.names, "").lines.join("\n");
+        return Source_1.serializeRenderResult(Source_1.sourcelikeToSource(src), this.names, "").lines.join("\n");
     }
     get commentLineStart() {
         return "// ";
@@ -562,7 +561,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         for (const line of lines) {
             let start = first ? firstLineStart : lineStart;
             if (this.sourcelikeToString(line) === "") {
-                start = (0, Strings_1.trimEnd)(start);
+                start = Strings_1.trimEnd(start);
             }
             this.emitLine(start, line);
             first = false;
@@ -599,19 +598,19 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         emitTable();
     }
     processGraph() {
-        this._declarationIR = (0, DeclarationIR_1.declarationsForGraph)(this.typeGraph, this.needsTypeDeclarationBeforeUse ? t => this.canBeForwardDeclared(t) : undefined, t => this.childrenOfType(t), t => {
+        this._declarationIR = DeclarationIR_1.declarationsForGraph(this.typeGraph, this.needsTypeDeclarationBeforeUse ? t => this.canBeForwardDeclared(t) : undefined, t => this.childrenOfType(t), t => {
             if (t instanceof Type_1.UnionType) {
                 return this.unionNeedsName(t);
             }
-            return (0, TypeUtils_1.isNamedType)(t);
+            return TypeUtils_1.isNamedType(t);
         });
         const types = this.typeGraph.allTypesUnordered();
-        this._haveUnions = (0, collection_utils_1.iterableSome)(types, t => t instanceof Type_1.UnionType);
-        this._haveMaps = (0, collection_utils_1.iterableSome)(types, t => t instanceof Type_1.MapType);
-        const classTypes = (0, collection_utils_1.setFilter)(types, t => t instanceof Type_1.ClassType);
-        this._haveOptionalProperties = (0, collection_utils_1.iterableSome)(classTypes, c => (0, collection_utils_1.mapSome)(c.getProperties(), p => p.isOptional));
+        this._haveUnions = collection_utils_1.iterableSome(types, t => t instanceof Type_1.UnionType);
+        this._haveMaps = collection_utils_1.iterableSome(types, t => t instanceof Type_1.MapType);
+        const classTypes = collection_utils_1.setFilter(types, t => t instanceof Type_1.ClassType);
+        this._haveOptionalProperties = collection_utils_1.iterableSome(classTypes, c => collection_utils_1.mapSome(c.getProperties(), p => p.isOptional));
         this._namedTypes = this._declarationIR.declarations.filter(d => d.kind === "define").map(d => d.type);
-        const { objects, enums, unions } = (0, TypeUtils_1.separateNamedTypes)(this._namedTypes);
+        const { objects, enums, unions } = TypeUtils_1.separateNamedTypes(this._namedTypes);
         this._namedObjects = new Set(objects);
         this._namedEnums = new Set(enums);
         this._namedUnions = new Set(unions);

package/dist/CycleBreaker.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.breakCycles = void 0;
 const Support_1 = require("./support/Support");
 function breakCycles(outEdges, chooseBreaker) {
     const numNodes = outEdges.length;
@@ -29,14 +28,14 @@ function breakCycles(outEdges, chooseBreaker) {
     }
     function removeNode(node) {
         for (const n of outEdges[node]) {
-            (0, Support_1.assert)(inDegree[n] > 0);
+            Support_1.assert(inDegree[n] > 0);
             inDegree[n] -= 1;
             if (inDegree[n] === 0) {
                 workList.push(n);
             }
         }
         for (const n of inEdges[node]) {
-            (0, Support_1.assert)(outDegree[n] > 0);
+            Support_1.assert(outDegree[n] > 0);
             outDegree[n] -= 1;
             if (outDegree[n] === 0) {
                 workList.push(n);
@@ -51,7 +50,7 @@ function breakCycles(outEdges, chooseBreaker) {
                 done[i] = true;
                 continue;
             }
-            (0, Support_1.assert)(inDegree[i] === 0 || outDegree[i] === 0, "Can't have nodes in the worklist with in and out edges");
+            Support_1.assert(inDegree[i] === 0 || outDegree[i] === 0, "Can't have nodes in the worklist with in and out edges");
             removeNode(i);
             continue;
         }
@@ -74,7 +73,7 @@ function breakCycles(outEdges, chooseBreaker) {
             // the dependee cycle.
             const maybeEdge = outEdges[n].find(x => !done[x]);
             if (maybeEdge === undefined) {
-                return (0, Support_1.panic)("Presumed cycle is not a cycle");
+                return Support_1.panic("Presumed cycle is not a cycle");
             }
             const maybeFirst = path.indexOf(maybeEdge);
             if (maybeFirst === undefined) {
@@ -86,7 +85,7 @@ function breakCycles(outEdges, chooseBreaker) {
             // We found a cycle - break it
             const cycle = path.slice(maybeFirst);
             const [breakNode, info] = chooseBreaker(cycle);
-            (0, Support_1.assert)(cycle.indexOf(breakNode) >= 0, "Breaker chose an invalid node");
+            Support_1.assert(cycle.indexOf(breakNode) >= 0, "Breaker chose an invalid node");
             removeNode(breakNode);
             results.push([breakNode, info]);
             break;

package/dist/DateTime.js

@@ -1,7 +1,6 @@
 "use strict";
 // https://github.com/epoberezkin/ajv/blob/4d76c6fb813b136b6ec4fe74990bc97233d75dea/lib/compile/formats.js
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultDateTimeRecognizer = void 0;
 /*
 The MIT License (MIT)
 

package/dist/DeclarationIR.d.ts

@@ -1,6 +1,6 @@
 import { TypeGraph } from "./TypeGraph";
 import { Type } from "./Type";
-export type DeclarationKind = "forward" | "define";
+export declare type DeclarationKind = "forward" | "define";
 export interface Declaration {
     readonly kind: DeclarationKind;
     readonly type: Type;