quicktype 17.0.1 → 17.0.3

package/dist/quicktype-core/Messages.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.messageAssert = exports.messageError = exports.QuickTypeError = void 0;
 const errorMessages = {
     InternalError: "Internal error: ${message}",
     // Misc
@@ -65,6 +66,9 @@ const errorMessages = {
     TypeScriptCompilerError: "TypeScript error: ${message}"
 };
 class QuickTypeError extends Error {
+    errorMessage;
+    messageName;
+    properties;
     constructor(errorMessage, messageName, userMessage, properties) {
         super(userMessage);
         this.errorMessage = errorMessage;
@@ -76,8 +80,9 @@ exports.QuickTypeError = QuickTypeError;
 function messageError(kind, properties) {
     const message = errorMessages[kind];
     let userMessage = message;
-    for (const name of Object.getOwnPropertyNames(properties)) {
-        let value = properties[name];
+    const propertiesMap = properties;
+    for (const name of Object.getOwnPropertyNames(propertiesMap)) {
+        let value = propertiesMap[name];
         if (typeof value === "object" && typeof value.toString === "function") {
             value = value.toString();
         }
@@ -89,7 +94,7 @@ function messageError(kind, properties) {
         }
         userMessage = userMessage.replace("${" + name + "}", value);
     }
-    throw new QuickTypeError(message, kind, userMessage, properties);
+    throw new QuickTypeError(message, kind, userMessage, propertiesMap);
 }
 exports.messageError = messageError;
 function messageAssert(assertion, kind, properties) {

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

@@ -5,12 +5,12 @@ export declare class Namespace {
     private readonly _members;
     constructor(_name: string, parent: Namespace | undefined, forbiddenNamespaces: Iterable<Namespace>, additionalForbidden: Iterable<Name>);
     private addChild;
-    readonly children: ReadonlySet<Namespace>;
-    readonly members: ReadonlySet<Name>;
-    readonly forbiddenNameds: ReadonlySet<Name>;
+    get children(): ReadonlySet<Namespace>;
+    get members(): ReadonlySet<Name>;
+    get forbiddenNameds(): ReadonlySet<Name>;
     add<TName extends Name>(named: TName): TName;
 }
-export declare type NameStyle = (rawName: string) => string;
+export type NameStyle = (rawName: string) => string;
 export declare class Namer {
     readonly name: string;
     readonly nameStyle: NameStyle;
@@ -25,9 +25,9 @@ export declare abstract class Name {
     private readonly _associates;
     constructor(_namingFunction: Namer | undefined, order: number);
     addAssociate(associate: AssociatedName): void;
-    abstract readonly dependencies: ReadonlyArray<Name>;
+    abstract get dependencies(): ReadonlyArray<Name>;
     isFixed(): this is FixedName;
-    readonly namingFunction: Namer;
+    get namingFunction(): Namer;
     abstract proposeUnstyledNames(names: ReadonlyMap<Name, string>): ReadonlySet<string>;
     firstProposedName(names: ReadonlyMap<Name, string>): string;
     nameAssignments(forbiddenNames: ReadonlySet<string>, assignedName: string): ReadonlyMap<Name, string> | null;
@@ -35,29 +35,29 @@ export declare abstract class Name {
 export declare class FixedName extends Name {
     private readonly _fixedName;
     constructor(_fixedName: string);
-    readonly dependencies: ReadonlyArray<Name>;
+    get dependencies(): ReadonlyArray<Name>;
     addAssociate(_: AssociatedName): never;
-    readonly fixedName: string;
+    get fixedName(): string;
     proposeUnstyledNames(_?: ReadonlyMap<Name, string>): ReadonlySet<string>;
 }
 export declare class SimpleName extends Name {
     private readonly _unstyledNames;
     constructor(unstyledNames: Iterable<string>, namingFunction: Namer, order: number);
-    readonly dependencies: ReadonlyArray<Name>;
+    get dependencies(): ReadonlyArray<Name>;
     proposeUnstyledNames(_?: ReadonlyMap<Name, string>): ReadonlySet<string>;
 }
 export declare class AssociatedName extends Name {
     private readonly _sponsor;
     readonly getName: (sponsorName: string) => string;
     constructor(_sponsor: Name, order: number, getName: (sponsorName: string) => string);
-    readonly dependencies: ReadonlyArray<Name>;
+    get dependencies(): ReadonlyArray<Name>;
     proposeUnstyledNames(_?: ReadonlyMap<Name, string>): never;
 }
 export declare class DependencyName extends Name {
     private readonly _proposeUnstyledName;
     private readonly _dependencies;
     constructor(namingFunction: Namer | undefined, order: number, _proposeUnstyledName: (lookup: (n: Name) => string) => string);
-    readonly dependencies: ReadonlyArray<Name>;
+    get dependencies(): ReadonlyArray<Name>;
     proposeUnstyledNames(names: ReadonlyMap<Name, string>): ReadonlySet<string>;
 }
 export declare function keywordNamespace(name: string, keywords: string[]): Namespace;

package/dist/quicktype-core/Naming.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignNames = exports.keywordNamespace = exports.DependencyName = exports.AssociatedName = exports.SimpleName = exports.FixedName = exports.Name = exports.funPrefixNamer = exports.Namer = exports.Namespace = void 0;
 const collection_utils_1 = require("collection-utils");
 const Support_1 = require("./support/Support");
 class Namespace {
+    forbiddenNamespaces;
+    additionalForbidden;
+    _children = new Set();
+    _members = new Set();
     constructor(_name, parent, forbiddenNamespaces, additionalForbidden) {
-        this._children = new Set();
-        this._members = new Set();
         this.forbiddenNamespaces = new Set(forbiddenNamespaces);
         this.additionalForbidden = new Set(additionalForbidden);
         if (parent !== undefined) {
@@ -23,7 +26,7 @@ class Namespace {
     }
     get forbiddenNameds() {
         // FIXME: cache
-        return collection_utils_1.setUnion(this.additionalForbidden, ...Array.from(this.forbiddenNamespaces).map(ns => ns.members));
+        return (0, collection_utils_1.setUnion)(this.additionalForbidden, ...Array.from(this.forbiddenNamespaces).map(ns => ns.members));
     }
     add(named) {
         this._members.add(named);
@@ -46,6 +49,9 @@ exports.Namespace = Namespace;
 // `Namer` is a class so that we can compare namers and put them into immutable
 // collections.
 class Namer {
+    name;
+    nameStyle;
+    _prefixes;
     constructor(name, nameStyle, prefixes) {
         this.name = name;
         this.nameStyle = nameStyle;
@@ -56,7 +62,7 @@ class Namer {
     assignNames(names, forbiddenNamesIterable, namesToAssignIterable) {
         const forbiddenNames = new Set(forbiddenNamesIterable);
         const namesToAssign = Array.from(namesToAssignIterable);
-        Support_1.assert(namesToAssign.length > 0, "Number of names can't be less than 1");
+        (0, Support_1.assert)(namesToAssign.length > 0, "Number of names can't be less than 1");
         const allAssignedNames = new Map();
         let namesToPrefix = [];
         for (const name of namesToAssign) {
@@ -64,14 +70,14 @@ class Namer {
             const namingFunction = name.namingFunction;
             // Find the first proposed name that isn't proposed by
             // any of the other names and that isn't already forbidden.
-            const maybeUniqueName = collection_utils_1.iterableFind(proposedNames, proposed => !forbiddenNames.has(namingFunction.nameStyle(proposed)) &&
+            const maybeUniqueName = (0, collection_utils_1.iterableFind)(proposedNames, proposed => !forbiddenNames.has(namingFunction.nameStyle(proposed)) &&
                 namesToAssign.every(n => n === name || !n.proposeUnstyledNames(names).has(proposed)));
             if (maybeUniqueName !== undefined) {
                 const styledName = namingFunction.nameStyle(maybeUniqueName);
                 const assigned = name.nameAssignments(forbiddenNames, styledName);
                 if (assigned !== null) {
-                    collection_utils_1.mapMergeInto(allAssignedNames, assigned);
-                    collection_utils_1.setUnionInto(forbiddenNames, assigned.values());
+                    (0, collection_utils_1.mapMergeInto)(allAssignedNames, assigned);
+                    (0, collection_utils_1.setUnionInto)(forbiddenNames, assigned.values());
                     continue;
                 }
             }
@@ -82,7 +88,7 @@ class Namer {
         let prefixes = this._prefixes.values();
         let suffixNumber = 1;
         for (const name of namesToPrefix) {
-            const originalName = Support_1.defined(collection_utils_1.iterableFirst(name.proposeUnstyledNames(names)));
+            const originalName = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(name.proposeUnstyledNames(names)));
             for (;;) {
                 let nameToTry;
                 const { done, value: prefix } = prefixes.next();
@@ -97,8 +103,8 @@ class Namer {
                 const assigned = name.nameAssignments(forbiddenNames, styledName);
                 if (assigned === null)
                     continue;
-                collection_utils_1.mapMergeInto(allAssignedNames, assigned);
-                collection_utils_1.setUnionInto(forbiddenNames, assigned.values());
+                (0, collection_utils_1.mapMergeInto)(allAssignedNames, assigned);
+                (0, collection_utils_1.setUnionInto)(forbiddenNames, assigned.values());
                 break;
             }
         }
@@ -130,11 +136,13 @@ exports.funPrefixNamer = funPrefixNamer;
 // own common superclass.  Most methods of `Name` make sense only either
 // for `FixedName` or the non-fixed names.
 class Name {
+    _namingFunction;
+    order;
+    _associates = new Set();
     // If a Named is fixed, the namingFunction is undefined.
     constructor(_namingFunction, order) {
         this._namingFunction = _namingFunction;
         this.order = order;
-        this._associates = new Set();
     }
     addAssociate(associate) {
         this._associates.add(associate);
@@ -143,10 +151,10 @@ class Name {
         return this instanceof FixedName;
     }
     get namingFunction() {
-        return Support_1.defined(this._namingFunction);
+        return (0, Support_1.defined)(this._namingFunction);
     }
     firstProposedName(names) {
-        return Support_1.defined(collection_utils_1.iterableFirst(this.proposeUnstyledNames(names)));
+        return (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(this.proposeUnstyledNames(names)));
     }
     nameAssignments(forbiddenNames, assignedName) {
         if (forbiddenNames.has(assignedName))
@@ -165,6 +173,7 @@ class Name {
 exports.Name = Name;
 // FIXME: FixedNameds should optionally be user-configurable
 class FixedName extends Name {
+    _fixedName;
     constructor(_fixedName) {
         super(undefined, 0);
         this._fixedName = _fixedName;
@@ -173,17 +182,18 @@ class FixedName extends Name {
         return [];
     }
     addAssociate(_) {
-        return Support_1.panic("Cannot add associates to fixed names");
+        return (0, Support_1.panic)("Cannot add associates to fixed names");
     }
     get fixedName() {
         return this._fixedName;
     }
     proposeUnstyledNames(_) {
-        return Support_1.panic("Only fixedName should be called on FixedName.");
+        return (0, Support_1.panic)("Only fixedName should be called on FixedName.");
     }
 }
 exports.FixedName = FixedName;
 class SimpleName extends Name {
+    _unstyledNames;
     constructor(unstyledNames, namingFunction, order) {
         super(namingFunction, order);
         this._unstyledNames = new Set(unstyledNames);
@@ -197,6 +207,8 @@ class SimpleName extends Name {
 }
 exports.SimpleName = SimpleName;
 class AssociatedName extends Name {
+    _sponsor;
+    getName;
     constructor(_sponsor, order, getName) {
         super(undefined, order);
         this._sponsor = _sponsor;
@@ -206,11 +218,13 @@ class AssociatedName extends Name {
         return [this._sponsor];
     }
     proposeUnstyledNames(_) {
-        return Support_1.panic("AssociatedName must be assigned via its sponsor");
+        return (0, Support_1.panic)("AssociatedName must be assigned via its sponsor");
     }
 }
 exports.AssociatedName = AssociatedName;
 class DependencyName extends Name {
+    _proposeUnstyledName;
+    _dependencies;
     constructor(namingFunction, order, _proposeUnstyledName) {
         super(namingFunction, order);
         this._proposeUnstyledName = _proposeUnstyledName;
@@ -227,8 +241,8 @@ class DependencyName extends Name {
     proposeUnstyledNames(names) {
         return new Set([
             this._proposeUnstyledName(n => {
-                Support_1.assert(this._dependencies.has(n), "DependencyName proposer is not pure");
-                return Support_1.defined(names.get(n));
+                (0, Support_1.assert)(this._dependencies.has(n), "DependencyName proposer is not pure");
+                return (0, Support_1.defined)(names.get(n));
             })
         ]);
     }
@@ -243,49 +257,50 @@ function keywordNamespace(name, keywords) {
 }
 exports.keywordNamespace = keywordNamespace;
 function allNamespacesRecursively(namespaces) {
-    return collection_utils_1.setUnion(namespaces, ...Array.from(collection_utils_1.setMap(namespaces, ns => allNamespacesRecursively(ns.children))));
+    return (0, collection_utils_1.setUnion)(namespaces, ...Array.from((0, collection_utils_1.setMap)(namespaces, ns => allNamespacesRecursively(ns.children))));
 }
 class NamingContext {
+    _names = new Map();
+    _namedsForName = new Map();
+    namespaces;
     constructor(rootNamespaces) {
-        this._names = new Map();
-        this._namedsForName = new Map();
-        this.isReadyToBeNamed = (named) => {
-            if (this._names.has(named))
-                return false;
-            return named.dependencies.every((n) => this._names.has(n));
-        };
-        this.isConflicting = (namedNamespace, proposed) => {
-            const namedsForProposed = this._namedsForName.get(proposed);
-            // If the name is not assigned at all, there is no conflict.
-            if (namedsForProposed === undefined)
-                return false;
-            // The name is assigned, but it might still not be forbidden.
-            for (const n of namedsForProposed) {
-                if (namedNamespace.members.has(n) || namedNamespace.forbiddenNameds.has(n)) {
-                    return true;
-                }
-            }
-            return false;
-        };
-        this.assign = (named, namedNamespace, name) => {
-            Support_1.assert(!this.names.has(named), `Name "${name}" assigned twice`);
-            Support_1.assert(!this.isConflicting(namedNamespace, name), `Assigned name "${name}" conflicts`);
-            this._names.set(named, name);
-            let namedsForName = this._namedsForName.get(name);
-            if (namedsForName === undefined) {
-                namedsForName = new Set();
-                this._namedsForName.set(name, namedsForName);
-            }
-            namedsForName.add(named);
-        };
         this.namespaces = allNamespacesRecursively(rootNamespaces);
     }
     get names() {
         return this._names;
     }
+    isReadyToBeNamed = (named) => {
+        if (this._names.has(named))
+            return false;
+        return named.dependencies.every((n) => this._names.has(n));
+    };
     areForbiddensFullyNamed(namespace) {
-        return collection_utils_1.iterableEvery(namespace.forbiddenNameds, n => this._names.has(n));
+        return (0, collection_utils_1.iterableEvery)(namespace.forbiddenNameds, n => this._names.has(n));
     }
+    isConflicting = (namedNamespace, proposed) => {
+        const namedsForProposed = this._namedsForName.get(proposed);
+        // If the name is not assigned at all, there is no conflict.
+        if (namedsForProposed === undefined)
+            return false;
+        // The name is assigned, but it might still not be forbidden.
+        for (const n of namedsForProposed) {
+            if (namedNamespace.members.has(n) || namedNamespace.forbiddenNameds.has(n)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    assign = (named, namedNamespace, name) => {
+        (0, Support_1.assert)(!this.names.has(named), `Name "${name}" assigned twice`);
+        (0, Support_1.assert)(!this.isConflicting(namedNamespace, name), `Assigned name "${name}" conflicts`);
+        this._names.set(named, name);
+        let namedsForName = this._namedsForName.get(name);
+        if (namedsForName === undefined) {
+            namedsForName = new Set();
+            this._namedsForName.set(name, namedsForName);
+        }
+        namedsForName.add(named);
+    };
 }
 // Naming algorithm
 function assignNames(rootNamespaces) {
@@ -303,36 +318,36 @@ function assignNames(rootNamespaces) {
         //    at least one unnamed Named that has all its dependencies satisfied.
         //    If no such namespace exists we're either done, or there's an unallowed
         //    cycle.
-        const unfinishedNamespaces = collection_utils_1.setFilter(ctx.namespaces, ns => ctx.areForbiddensFullyNamed(ns));
-        const readyNamespace = collection_utils_1.iterableFind(unfinishedNamespaces, ns => collection_utils_1.iterableSome(ns.members, ctx.isReadyToBeNamed));
+        const unfinishedNamespaces = (0, collection_utils_1.setFilter)(ctx.namespaces, ns => ctx.areForbiddensFullyNamed(ns));
+        const readyNamespace = (0, collection_utils_1.iterableFind)(unfinishedNamespaces, ns => (0, collection_utils_1.iterableSome)(ns.members, ctx.isReadyToBeNamed));
         if (readyNamespace === undefined) {
             // FIXME: Check for cycles?
             return ctx.names;
         }
-        const allForbiddenNames = collection_utils_1.setUnion(readyNamespace.members, readyNamespace.forbiddenNameds);
-        let forbiddenNames = collection_utils_1.setFilterMap(allForbiddenNames, n => ctx.names.get(n));
+        const allForbiddenNames = (0, collection_utils_1.setUnion)(readyNamespace.members, readyNamespace.forbiddenNameds);
+        let forbiddenNames = (0, collection_utils_1.setFilterMap)(allForbiddenNames, n => ctx.names.get(n));
         // 2. From low order to high order, sort those names into sets where all
         //    members of a set propose the same name and have the same naming
         //    function.
         for (;;) {
-            const allReadyNames = collection_utils_1.setFilter(readyNamespace.members, ctx.isReadyToBeNamed);
-            const minOrderName = collection_utils_1.iterableMinBy(allReadyNames, n => n.order);
+            const allReadyNames = (0, collection_utils_1.setFilter)(readyNamespace.members, ctx.isReadyToBeNamed);
+            const minOrderName = (0, collection_utils_1.iterableMinBy)(allReadyNames, n => n.order);
             if (minOrderName === undefined)
                 break;
             const minOrder = minOrderName.order;
-            const readyNames = collection_utils_1.setFilter(allReadyNames, n => n.order === minOrder);
+            const readyNames = (0, collection_utils_1.setFilter)(allReadyNames, n => n.order === minOrder);
             // It would be nice if we had tuples, then we wouldn't have to do this in
             // two steps.
-            const byNamingFunction = collection_utils_1.setGroupBy(readyNames, n => n.namingFunction);
+            const byNamingFunction = (0, collection_utils_1.setGroupBy)(readyNames, n => n.namingFunction);
             for (const [namer, namedsForNamingFunction] of byNamingFunction) {
-                const byProposed = collection_utils_1.setGroupBy(namedsForNamingFunction, n => n.namingFunction.nameStyle(n.firstProposedName(ctx.names)));
+                const byProposed = (0, collection_utils_1.setGroupBy)(namedsForNamingFunction, n => n.namingFunction.nameStyle(n.firstProposedName(ctx.names)));
                 for (const [, nameds] of byProposed) {
                     // 3. Use each set's naming function to name its members.
                     const names = namer.assignNames(ctx.names, forbiddenNames, nameds);
                     for (const [name, assigned] of names) {
                         ctx.assign(name, readyNamespace, assigned);
                     }
-                    collection_utils_1.setUnionInto(forbiddenNames, names.values());
+                    (0, collection_utils_1.setUnionInto)(forbiddenNames, names.values());
                 }
             }
         }

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

@@ -3,17 +3,17 @@ import { Name, Namespace } from "./Naming";
 import { Source, Sourcelike } from "./Source";
 import { AnnotationData } from "./Annotation";
 import { TargetLanguage } from "./TargetLanguage";
-export declare type RenderResult = {
+export type RenderResult = {
     sources: ReadonlyMap<string, Source>;
     names: ReadonlyMap<Name, string>;
 };
-export declare type BlankLinePosition = "none" | "interposing" | "leading" | "leading-and-interposing";
-export declare type BlankLineConfig = BlankLinePosition | [BlankLinePosition, number];
-export declare type RenderContext = {
+export type BlankLinePosition = "none" | "interposing" | "leading" | "leading-and-interposing";
+export type BlankLineConfig = BlankLinePosition | [BlankLinePosition, number];
+export type RenderContext = {
     typeGraph: TypeGraph;
     leadingComments: string[] | undefined;
 };
-export declare type ForEachPosition = "first" | "last" | "middle" | "only";
+export type ForEachPosition = "first" | "last" | "middle" | "only";
 export declare abstract class Renderer {
     protected readonly targetLanguage: TargetLanguage;
     protected readonly typeGraph: TypeGraph;
@@ -46,5 +46,5 @@ export declare abstract class Renderer {
     protected initializeEmitContextForFilename(filename: string): void;
     protected finishFile(filename: string): void;
     render(givenOutputFilename: string): RenderResult;
-    readonly names: ReadonlyMap<Name, string>;
+    get names(): ReadonlyMap<Name, string>;
 }

package/dist/quicktype-core/Renderer.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Renderer = void 0;
 const collection_utils_1 = require("collection-utils");
 const Naming_1 = require("./Naming");
 const Source_1 = require("./Source");
@@ -29,6 +30,15 @@ function lineIndentation(line) {
     return { indent: 0, text: null };
 }
 class EmitContext {
+    _lastNewline;
+    // @ts-ignore: Initialized in startEmit, which is called from the constructor
+    _emitted;
+    // @ts-ignore: Initialized in startEmit, which is called from the constructor
+    _currentEmitTarget;
+    // @ts-ignore: Initialized in startEmit, which is called from the constructor
+    _numBlankLinesNeeded;
+    // @ts-ignore: Initialized in startEmit, which is called from the constructor
+    _preventBlankLine;
     constructor() {
         this._currentEmitTarget = this._emitted = [];
         this._numBlankLinesNeeded = 0;
@@ -48,7 +58,7 @@ class EmitContext {
         this._preventBlankLine = false;
     }
     emitNewline() {
-        const nl = Source_1.newline();
+        const nl = (0, Source_1.newline)();
         this.pushItem(nl);
         this._lastNewline = nl;
     }
@@ -76,21 +86,21 @@ class EmitContext {
     }
     changeIndent(offset) {
         if (this._lastNewline === undefined) {
-            return Support_1.panic("Cannot change indent for the first line");
+            return (0, Support_1.panic)("Cannot change indent for the first line");
         }
         this._lastNewline.indentationChange += offset;
     }
 }
 class Renderer {
+    targetLanguage;
+    typeGraph;
+    leadingComments;
+    _names;
+    _finishedFiles;
+    _finishedEmitContexts;
+    _emitContext;
     constructor(targetLanguage, renderContext) {
         this.targetLanguage = targetLanguage;
-        this.emitTable = (tableArray) => {
-            if (tableArray.length === 0)
-                return;
-            const table = tableArray.map(r => r.map(sl => Source_1.sourcelikeToSource(sl)));
-            this._emitContext.emitItem({ kind: "table", table });
-            this._emitContext.emitNewline();
-        };
         this.typeGraph = renderContext.typeGraph;
         this.leadingComments = renderContext.leadingComments;
         this._finishedFiles = new Map();
@@ -144,7 +154,7 @@ class Renderer {
         for (let i = 1; i < numLines; i++) {
             const line = lines[i];
             const { indent, text } = lineIndentation(line);
-            Support_1.assert(indent % 4 === 0, "Indentation is not a multiple of 4.");
+            (0, Support_1.assert)(indent % 4 === 0, "Indentation is not a multiple of 4.");
             if (text !== null) {
                 const newIndent = indent / 4;
                 this.changeIndent(newIndent - currentIndent);
@@ -163,7 +173,7 @@ class Renderer {
         const oldEmitContext = this._emitContext;
         this._emitContext = new EmitContext();
         emitter();
-        Support_1.assert(!this._emitContext.isNested, "emit context not restored correctly");
+        (0, Support_1.assert)(!this._emitContext.isNested, "emit context not restored correctly");
         const source = this._emitContext.source;
         this._emitContext = oldEmitContext;
         return source;
@@ -175,19 +185,26 @@ class Renderer {
     }
     emitAnnotated(annotation, emitter) {
         const lines = this.gatherSource(emitter);
-        const source = Source_1.sourcelikeToSource(lines);
-        this._emitContext.emitItem(Source_1.annotated(annotation, source));
+        const source = (0, Source_1.sourcelikeToSource)(lines);
+        this._emitContext.emitItem((0, Source_1.annotated)(annotation, source));
     }
     emitIssue(message, emitter) {
         this.emitAnnotated(new Annotation_1.IssueAnnotationData(message), emitter);
     }
+    emitTable = (tableArray) => {
+        if (tableArray.length === 0)
+            return;
+        const table = tableArray.map(r => r.map(sl => (0, Source_1.sourcelikeToSource)(sl)));
+        this._emitContext.emitItem({ kind: "table", table });
+        this._emitContext.emitNewline();
+    };
     changeIndent(offset) {
         this._emitContext.changeIndent(offset);
     }
     iterableForEach(iterable, emitter) {
         const items = Array.from(iterable);
         let onFirst = true;
-        for (const [i, v] of collection_utils_1.iterableEnumerate(items)) {
+        for (const [i, v] of (0, collection_utils_1.iterableEnumerate)(items)) {
             const position = items.length === 1 ? "only" : onFirst ? "first" : i === items.length - 1 ? "last" : "middle";
             emitter(v, position);
             onFirst = false;
@@ -219,7 +236,7 @@ class Renderer {
         this.changeIndent(-1);
     }
     assignNames() {
-        return Naming_1.assignNames(this.setUpNaming());
+        return (0, Naming_1.assignNames)(this.setUpNaming());
     }
     initializeEmitContextForFilename(filename) {
         if (this._finishedEmitContexts.has(filename.toLowerCase())) {
@@ -233,7 +250,7 @@ class Renderer {
         if (this._finishedFiles.has(filename)) {
             console.log(`[WARNING] Tried to emit file ${filename} more than once. If performing multi-file output this warning can be safely ignored.`);
         }
-        const source = Source_1.sourcelikeToSource(this._emitContext.source);
+        const source = (0, Source_1.sourcelikeToSource)(this._emitContext.source);
         this._finishedFiles.set(filename, source);
         // [Michael Fey (@MrRooni), 2019-5-9] We save the current EmitContext for possible reuse later. We put it into the map with a lowercased version of the key so we can do a case-insensitive lookup later. The reason we lowercase it is because some schema (looking at you keyword-unions.schema) define objects of the same name with different casing. BOOL vs. bool, for example.
         this._finishedEmitContexts.set(filename.toLowerCase(), this._emitContext);
@@ -249,7 +266,7 @@ class Renderer {
     }
     get names() {
         if (this._names === undefined) {
-            return Support_1.panic("Names accessed before they were assigned");
+            return (0, Support_1.panic)("Names accessed before they were assigned");
         }
         return this._names;
     }

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

@@ -2,7 +2,7 @@
  * Primary options show up in the web UI in the "Language" settings tab,
  * secondary options in "Other".
  */
-export declare type OptionKind = "primary" | "secondary";
+export type OptionKind = "primary" | "secondary";
 export interface OptionDefinition {
     name: string;
     type: StringConstructor | BooleanConstructor;
@@ -26,13 +26,13 @@ export declare abstract class Option<T> {
     getValue(values: {
         [name: string]: any;
     }): T;
-    readonly cliDefinitions: {
+    get cliDefinitions(): {
         display: OptionDefinition[];
         actual: OptionDefinition[];
     };
 }
-export declare type OptionValueType<O> = O extends Option<infer T> ? T : never;
-export declare type OptionValues<T> = {
+export type OptionValueType<O> = O extends Option<infer T> ? T : never;
+export type OptionValues<T> = {
     [P in keyof T]: OptionValueType<T[P]>;
 };
 export declare function getOptionValues<T extends {
@@ -51,7 +51,7 @@ export declare class BooleanOption extends Option<boolean> {
      * @param kind Whether it's a primary or secondary option.
      */
     constructor(name: string, description: string, defaultValue: boolean, kind?: OptionKind);
-    readonly cliDefinitions: {
+    get cliDefinitions(): {
         display: OptionDefinition[];
         actual: OptionDefinition[];
     };

package/dist/quicktype-core/RendererOptions.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumOption = exports.StringOption = exports.BooleanOption = exports.getOptionValues = exports.Option = void 0;
 const Support_1 = require("./support/Support");
 const Messages_1 = require("./Messages");
 const collection_utils_1 = require("collection-utils");
@@ -8,10 +9,11 @@ const collection_utils_1 = require("collection-utils");
  * subclasses, `BooleanOption`, `EnumOption`, or `StringOption`.
  */
 class Option {
+    definition;
     constructor(definition) {
         definition.renderer = true;
         this.definition = definition;
-        Support_1.assert(definition.kind !== undefined, "Renderer option kind must be defined");
+        (0, Support_1.assert)(definition.kind !== undefined, "Renderer option kind must be defined");
     }
     getValue(values) {
         const value = values[this.definition.name];
@@ -105,6 +107,7 @@ class StringOption extends Option {
 }
 exports.StringOption = StringOption;
 class EnumOption extends Option {
+    _values;
     constructor(name, description, values, defaultValue = undefined, kind = "primary") {
         if (defaultValue === undefined) {
             defaultValue = values[0][0];
@@ -129,8 +132,8 @@ class EnumOption extends Option {
         if (name === undefined) {
             name = this.definition.defaultValue;
         }
-        if (!collection_utils_1.hasOwnProperty(this._values, name)) {
-            return Messages_1.messageError("RendererUnknownOptionValue", { value: name, name: this.definition.name });
+        if (!(0, collection_utils_1.hasOwnProperty)(this._values, name)) {
+            return (0, Messages_1.messageError)("RendererUnknownOptionValue", { value: name, name: this.definition.name });
         }
         return this._values[name];
     }