quicktype 16.0.42 → 17.0.0

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

@@ -4,7 +4,7 @@ import { StringTypeMapping } from "./TypeBuilder";
 import { InputData } from "./input/Inputs";
 import { TransformedStringTypeKind } from "./Type";
 export declare function getTargetLanguage(nameOrInstance: string | TargetLanguage): TargetLanguage;
-export declare type RendererOptions = {
+export type RendererOptions = {
     [name: string]: string;
 };
 export interface InferenceFlag {
@@ -34,7 +34,7 @@ export declare const inferenceFlagsObject: {
         description: string;
         negationDescription: string;
         explanation: string;
-        stringType: "time" | "date" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
+        stringType: "date" | "time" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
         order: number;
     };
     /** Whether to assume that JSON strings that look like dates are dates */
@@ -42,7 +42,7 @@ export declare const inferenceFlagsObject: {
         description: string;
         negationDescription: string;
         explanation: string;
-        stringType: "time" | "date" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
+        stringType: "date" | "time" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
         order: number;
     };
     /** Whether to convert stringified integers to integers */
@@ -50,7 +50,7 @@ export declare const inferenceFlagsObject: {
         description: string;
         negationDescription: string;
         explanation: string;
-        stringType: "time" | "date" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
+        stringType: "date" | "time" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
         order: number;
     };
     /** Whether to convert stringified booleans to boolean values */
@@ -58,7 +58,7 @@ export declare const inferenceFlagsObject: {
         description: string;
         negationDescription: string;
         explanation: string;
-        stringType: "time" | "date" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
+        stringType: "date" | "time" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
         order: number;
     };
     /** Combine similar classes.  This doesn't apply to classes from a schema, only from inference. */
@@ -76,19 +76,19 @@ export declare const inferenceFlagsObject: {
         order: number;
     };
 };
-export declare type InferenceFlagName = keyof typeof inferenceFlagsObject;
+export type InferenceFlagName = keyof typeof inferenceFlagsObject;
 export declare const inferenceFlagNames: ("inferMaps" | "inferEnums" | "inferUuids" | "inferDateTimes" | "inferIntegerStrings" | "inferBooleanStrings" | "combineClasses" | "ignoreJsonRefs")[];
 export declare const inferenceFlags: {
     [F in InferenceFlagName]: InferenceFlag;
 };
-export declare type InferenceFlags = {
+export type InferenceFlags = {
     [F in InferenceFlagName]: boolean;
 };
 /**
  * The options type for the main quicktype entry points,
  * `quicktypeMultiFile` and `quicktype`.
  */
-export declare type NonInferenceOptions = {
+export type NonInferenceOptions = {
     /**
      * The target language for which to produce code.  This can be either an instance of `TargetLanguage`,
      * or a string specifying one of the names for quicktype's built-in target languages.  For example,
@@ -139,7 +139,7 @@ export declare type NonInferenceOptions = {
     /** Print schema resolving steps */
     debugPrintSchemaResolving: boolean;
 };
-export declare type Options = NonInferenceOptions & InferenceFlags;
+export type Options = NonInferenceOptions & InferenceFlags;
 export interface RunContext {
     stringTypeMapping: StringTypeMapping;
     debugPrintReconstitution: boolean;

package/dist/quicktype-core/Run.js

@@ -1,15 +1,31 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+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.quicktype = exports.combineRenderResults = exports.quicktypeMultiFileSync = exports.quicktypeMultiFile = exports.defaultInferenceFlags = exports.inferenceFlags = exports.inferenceFlagNames = exports.inferenceFlagsObject = exports.getTargetLanguage = void 0;
 const collection_utils_1 = require("collection-utils");
-const targetLanguages = require("./language/All");
+const targetLanguages = __importStar(require("./language/All"));
 const Support_1 = require("./support/Support");
 const CombineClasses_1 = require("./rewrites/CombineClasses");
 const InferMaps_1 = require("./rewrites/InferMaps");
@@ -33,7 +49,7 @@ function getTargetLanguage(nameOrInstance) {
     if (language !== undefined) {
         return language;
     }
-    return Messages_1.messageError("DriverUnknownOutputLanguage", { lang: nameOrInstance });
+    return (0, Messages_1.messageError)("DriverUnknownOutputLanguage", { lang: nameOrInstance });
 }
 exports.getTargetLanguage = getTargetLanguage;
 exports.inferenceFlagsObject = {
@@ -128,6 +144,7 @@ function makeDefaultInferenceFlags() {
 }
 exports.defaultInferenceFlags = makeDefaultInferenceFlags();
 class Run {
+    _options;
     constructor(options) {
         // We must not overwrite defaults with undefined values, which
         // we sometimes get.
@@ -159,16 +176,14 @@ class Run {
     get debugPrintSchemaResolving() {
         return this._options.debugPrintSchemaResolving;
     }
-    timeSync(name, f) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const start = Date.now();
-            const result = yield f();
-            const end = Date.now();
-            if (this._options.debugPrintTimes) {
-                console.log(`${name} took ${end - start}ms`);
-            }
-            return result;
-        });
+    async timeSync(name, f) {
+        const start = Date.now();
+        const result = await f();
+        const end = Date.now();
+        if (this._options.debugPrintTimes) {
+            console.log(`${name} took ${end - start}ms`);
+        }
+        return result;
     }
     time(name, f) {
         const start = Date.now();
@@ -186,14 +201,10 @@ class Run {
         const typeBuilder = new TypeBuilder_1.TypeBuilder(0, stringTypeMapping, this._options.alphabetizeProperties, this._options.allPropertiesOptional, this._options.checkProvenance, false);
         return { targetLanguage, stringTypeMapping, conflateNumbers, typeBuilder };
     }
-    makeGraph(allInputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const graphInputs = this.makeGraphInputs();
-            yield this.timeSync("read input", () => __awaiter(this, void 0, void 0, function* () {
-                return yield allInputs.addTypes(this, graphInputs.typeBuilder, this._options.inferMaps, this._options.inferEnums, this._options.fixedTopLevels);
-            }));
-            return this.processGraph(allInputs, graphInputs);
-        });
+    async makeGraph(allInputs) {
+        const graphInputs = this.makeGraphInputs();
+        await this.timeSync("read input", async () => await allInputs.addTypes(this, graphInputs.typeBuilder, this._options.inferMaps, this._options.inferEnums, this._options.fixedTopLevels));
+        return this.processGraph(allInputs, graphInputs);
     }
     makeGraphSync(allInputs) {
         const graphInputs = this.makeGraphInputs();
@@ -209,7 +220,7 @@ class Run {
         }
         const debugPrintReconstitution = this.debugPrintReconstitution;
         if (typeBuilder.didAddForwardingIntersection || !this._options.ignoreJsonRefs) {
-            this.time("remove indirection intersections", () => (graph = TypeGraph_1.removeIndirectionIntersections(graph, stringTypeMapping, debugPrintReconstitution)));
+            this.time("remove indirection intersections", () => (graph = (0, TypeGraph_1.removeIndirectionIntersections)(graph, stringTypeMapping, debugPrintReconstitution)));
         }
         let unionsDone = false;
         if (allInputs.needSchemaProcessing || !this._options.ignoreJsonRefs) {
@@ -217,32 +228,32 @@ class Run {
             do {
                 const graphBeforeRewrites = graph;
                 if (!intersectionsDone) {
-                    this.time("resolve intersections", () => ([graph, intersectionsDone] = ResolveIntersections_1.resolveIntersections(graph, stringTypeMapping, debugPrintReconstitution)));
+                    this.time("resolve intersections", () => ([graph, intersectionsDone] = (0, ResolveIntersections_1.resolveIntersections)(graph, stringTypeMapping, debugPrintReconstitution)));
                 }
                 if (!unionsDone) {
-                    this.time("flatten unions", () => ([graph, unionsDone] = FlattenUnions_1.flattenUnions(graph, stringTypeMapping, conflateNumbers, true, debugPrintReconstitution)));
+                    this.time("flatten unions", () => ([graph, unionsDone] = (0, FlattenUnions_1.flattenUnions)(graph, stringTypeMapping, conflateNumbers, true, debugPrintReconstitution)));
                 }
                 if (graph === graphBeforeRewrites) {
-                    Support_1.assert(intersectionsDone && unionsDone, "Graph didn't change but we're not done");
+                    (0, Support_1.assert)(intersectionsDone && unionsDone, "Graph didn't change but we're not done");
                 }
             } while (!intersectionsDone || !unionsDone);
         }
-        this.time("replace object type", () => (graph = ReplaceObjectType_1.replaceObjectType(graph, stringTypeMapping, conflateNumbers, targetLanguage.supportsFullObjectType, debugPrintReconstitution)));
+        this.time("replace object type", () => (graph = (0, ReplaceObjectType_1.replaceObjectType)(graph, stringTypeMapping, conflateNumbers, targetLanguage.supportsFullObjectType, debugPrintReconstitution)));
         do {
-            this.time("flatten unions", () => ([graph, unionsDone] = FlattenUnions_1.flattenUnions(graph, stringTypeMapping, conflateNumbers, false, debugPrintReconstitution)));
+            this.time("flatten unions", () => ([graph, unionsDone] = (0, FlattenUnions_1.flattenUnions)(graph, stringTypeMapping, conflateNumbers, false, debugPrintReconstitution)));
         } while (!unionsDone);
         if (this._options.combineClasses) {
-            const combinedGraph = this.time("combine classes", () => CombineClasses_1.combineClasses(this, graph, this._options.alphabetizeProperties, true, false, debugPrintReconstitution));
+            const combinedGraph = this.time("combine classes", () => (0, CombineClasses_1.combineClasses)(this, graph, this._options.alphabetizeProperties, true, false, debugPrintReconstitution));
             if (combinedGraph === graph) {
                 graph = combinedGraph;
             }
             else {
-                this.time("combine classes cleanup", () => (graph = CombineClasses_1.combineClasses(this, combinedGraph, this._options.alphabetizeProperties, false, true, debugPrintReconstitution)));
+                this.time("combine classes cleanup", () => (graph = (0, CombineClasses_1.combineClasses)(this, combinedGraph, this._options.alphabetizeProperties, false, true, debugPrintReconstitution)));
             }
         }
         if (this._options.inferMaps) {
             for (;;) {
-                const newGraph = this.time("infer maps", () => InferMaps_1.inferMaps(graph, stringTypeMapping, true, debugPrintReconstitution));
+                const newGraph = this.time("infer maps", () => (0, InferMaps_1.inferMaps)(graph, stringTypeMapping, true, debugPrintReconstitution));
                 if (newGraph === graph) {
                     break;
                 }
@@ -250,20 +261,20 @@ class Run {
             }
         }
         const enumInference = allInputs.needSchemaProcessing ? "all" : this._options.inferEnums ? "infer" : "none";
-        this.time("expand strings", () => (graph = ExpandStrings_1.expandStrings(this, graph, enumInference)));
-        this.time("flatten unions", () => ([graph, unionsDone] = FlattenUnions_1.flattenUnions(graph, stringTypeMapping, conflateNumbers, false, debugPrintReconstitution)));
-        Support_1.assert(unionsDone, "We should only have to flatten unions once after expanding strings");
+        this.time("expand strings", () => (graph = (0, ExpandStrings_1.expandStrings)(this, graph, enumInference)));
+        this.time("flatten unions", () => ([graph, unionsDone] = (0, FlattenUnions_1.flattenUnions)(graph, stringTypeMapping, conflateNumbers, false, debugPrintReconstitution)));
+        (0, Support_1.assert)(unionsDone, "We should only have to flatten unions once after expanding strings");
         if (allInputs.needSchemaProcessing) {
-            this.time("flatten strings", () => (graph = FlattenStrings_1.flattenStrings(graph, stringTypeMapping, debugPrintReconstitution)));
+            this.time("flatten strings", () => (graph = (0, FlattenStrings_1.flattenStrings)(graph, stringTypeMapping, debugPrintReconstitution)));
         }
-        this.time("none to any", () => (graph = TypeGraph_1.noneToAny(graph, stringTypeMapping, debugPrintReconstitution)));
+        this.time("none to any", () => (graph = (0, TypeGraph_1.noneToAny)(graph, stringTypeMapping, debugPrintReconstitution)));
         if (!targetLanguage.supportsOptionalClassProperties) {
-            this.time("optional to nullable", () => (graph = TypeGraph_1.optionalToNullable(graph, stringTypeMapping, debugPrintReconstitution)));
+            this.time("optional to nullable", () => (graph = (0, TypeGraph_1.optionalToNullable)(graph, stringTypeMapping, debugPrintReconstitution)));
         }
         this.time("fixed point", () => (graph = graph.rewriteFixedPoint(false, debugPrintReconstitution)));
-        this.time("make transformations", () => (graph = MakeTransformations_1.makeTransformations(this, graph, targetLanguage)));
-        this.time("flatten unions", () => ([graph, unionsDone] = FlattenUnions_1.flattenUnions(graph, stringTypeMapping, conflateNumbers, false, debugPrintReconstitution)));
-        Support_1.assert(unionsDone, "We should only have to flatten unions once after making transformations");
+        this.time("make transformations", () => (graph = (0, MakeTransformations_1.makeTransformations)(this, graph, targetLanguage)));
+        this.time("flatten unions", () => ([graph, unionsDone] = (0, FlattenUnions_1.flattenUnions)(graph, stringTypeMapping, conflateNumbers, false, debugPrintReconstitution)));
+        (0, Support_1.assert)(unionsDone, "We should only have to flatten unions once after making transformations");
         // Sometimes we combine classes in ways that will the order come out
         // differently compared to what it would be from the equivalent schema,
         // so we always just garbage collect to get a defined order and be done
@@ -275,7 +286,7 @@ class Run {
         if (this._options.debugPrintGraph) {
             console.log("\n# gather names");
         }
-        this.time("gather names", () => GatherNames_1.gatherNames(graph, !allInputs.needSchemaProcessing, this._options.debugPrintGatherNames));
+        this.time("gather names", () => (0, GatherNames_1.gatherNames)(graph, !allInputs.needSchemaProcessing, this._options.debugPrintGatherNames));
         if (this._options.debugPrintGraph) {
             graph.printGraph();
         }
@@ -286,7 +297,7 @@ class Run {
     }
     preRun() {
         // FIXME: This makes quicktype not quite reentrant
-        TypeNames_1.initTypeNames();
+        (0, TypeNames_1.initTypeNames)();
         const targetLanguage = getTargetLanguage(this._options.lang);
         const inputData = this._options.inputData;
         const needIR = inputData.needIR || targetLanguage.names.indexOf("schema") < 0;
@@ -299,16 +310,14 @@ class Run {
         }
         return [inputData, targetLanguage];
     }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const preRunResult = this.preRun();
-            if (!Array.isArray(preRunResult)) {
-                return preRunResult;
-            }
-            const [inputData, targetLanguage] = preRunResult;
-            const graph = yield this.makeGraph(inputData);
-            return this.renderGraph(targetLanguage, graph);
-        });
+    async run() {
+        const preRunResult = this.preRun();
+        if (!Array.isArray(preRunResult)) {
+            return preRunResult;
+        }
+        const [inputData, targetLanguage] = preRunResult;
+        const graph = await this.makeGraph(inputData);
+        return this.renderGraph(targetLanguage, graph);
     }
     runSync() {
         const preRunResult = this.preRun();
@@ -332,10 +341,8 @@ class Run {
  * @param options Partial options.  For options that are not defined, the
  * defaults will be used.
  */
-function quicktypeMultiFile(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield new Run(options).run();
-    });
+async function quicktypeMultiFile(options) {
+    return await new Run(options).run();
 }
 exports.quicktypeMultiFile = quicktypeMultiFile;
 function quicktypeMultiFileSync(options) {
@@ -355,7 +362,7 @@ function offsetSpan(span, lineOffset) {
  */
 function combineRenderResults(result) {
     if (result.size <= 1) {
-        const first = collection_utils_1.mapFirst(result);
+        const first = (0, collection_utils_1.mapFirst)(result);
         if (first === undefined) {
             return { lines: [], annotations: [] };
         }
@@ -379,10 +386,8 @@ exports.combineRenderResults = combineRenderResults;
  * @param options Partial options.  For options that are not defined, the
  * defaults will be used.
  */
-function quicktype(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const result = yield quicktypeMultiFile(options);
-        return combineRenderResults(result);
-    });
+async function quicktype(options) {
+    const result = await quicktypeMultiFile(options);
+    return combineRenderResults(result);
 }
 exports.quicktype = quicktype;

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

@@ -1,6 +1,6 @@
 import { AnnotationData } from "./Annotation";
 import { Name } from "./Naming";
-export declare type Source = TextSource | NewlineSource | SequenceSource | TableSource | AnnotatedSource | NameSource | ModifiedSource;
+export type Source = TextSource | NewlineSource | SequenceSource | TableSource | AnnotatedSource | NameSource | ModifiedSource;
 export interface TextSource {
     kind: "text";
     text: string;
@@ -32,7 +32,7 @@ export interface ModifiedSource {
     source: Source;
 }
 export declare function newline(): NewlineSource;
-export declare type Sourcelike = Source | string | Name | SourcelikeArray;
+export type Sourcelike = Source | string | Name | SourcelikeArray;
 export interface SourcelikeArray extends Array<Sourcelike> {
 }
 export declare function sourcelikeToSource(sl: Sourcelike): Source;
@@ -56,7 +56,7 @@ export interface SerializedRenderResult {
     annotations: ReadonlyArray<Annotation>;
 }
 export declare function serializeRenderResult(rootSource: Source, names: ReadonlyMap<Name, string>, indentation: string): SerializedRenderResult;
-export declare type MultiWord = {
+export type MultiWord = {
     source: Sourcelike;
     needsParens: boolean;
 };

package/dist/quicktype-core/Source.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parenIfNeeded = exports.multiWord = exports.singleWord = exports.serializeRenderResult = exports.modifySource = exports.maybeAnnotated = exports.annotated = exports.sourcelikeToSource = exports.newline = void 0;
 const collection_utils_1 = require("collection-utils");
 const Naming_1 = require("./Naming");
 const Support_1 = require("./support/Support");
@@ -24,7 +25,7 @@ function sourcelikeToSource(sl) {
         }
         return {
             kind: "sequence",
-            sequence: collection_utils_1.arrayIntercalate(newline(), lines.map((l) => ({ kind: "text", text: l })))
+            sequence: (0, collection_utils_1.arrayIntercalate)(newline(), lines.map((l) => ({ kind: "text", text: l })))
         };
     }
     if (sl instanceof Naming_1.Name) {
@@ -61,21 +62,21 @@ function sourceLineLength(source, names) {
         case "text":
             return source.text.length;
         case "newline":
-            return Support_1.panic("Newline must not occur within a line.");
+            return (0, Support_1.panic)("Newline must not occur within a line.");
         case "sequence":
             return source.sequence
                 .map((s) => sourceLineLength(s, names))
                 .reduce((a, b) => a + b, 0);
         case "table":
-            return Support_1.panic("Table must not occur within a  line.");
+            return (0, Support_1.panic)("Table must not occur within a  line.");
         case "annotated":
             return sourceLineLength(source.source, names);
         case "name":
-            return Support_1.defined(names.get(source.named)).length;
+            return (0, Support_1.defined)(names.get(source.named)).length;
         case "modified":
             return serializeRenderResult(source, names, "").lines.join("\n").length;
         default:
-            return Support_1.assertNever(source);
+            return (0, Support_1.assertNever)(source);
     }
 }
 function serializeRenderResult(rootSource, names, indentation) {
@@ -87,7 +88,7 @@ function serializeRenderResult(rootSource, names, indentation) {
     function indentIfNeeded() {
         if (indentNeeded === 0)
             return;
-        currentLine.push(Strings_1.repeatString(indentation, indentNeeded));
+        currentLine.push((0, Strings_1.repeatString)(indentation, indentNeeded));
         indentNeeded = 0;
     }
     function flattenCurrentLine() {
@@ -124,24 +125,24 @@ function serializeRenderResult(rootSource, names, indentation) {
                 if (numRows === 0)
                     break;
                 const widths = t.map(l => l.map(s => sourceLineLength(s, names)));
-                const numColumns = Support_1.defined(collection_utils_1.iterableMax(t.map(l => l.length)));
+                const numColumns = (0, Support_1.defined)((0, collection_utils_1.iterableMax)(t.map(l => l.length)));
                 if (numColumns === 0)
                     break;
                 const columnWidths = [];
                 for (let i = 0; i < numColumns; i++) {
-                    columnWidths.push(Support_1.defined(collection_utils_1.iterableMax(widths.map(l => collection_utils_1.withDefault(l[i], 0)))));
+                    columnWidths.push((0, Support_1.defined)((0, collection_utils_1.iterableMax)(widths.map(l => (0, collection_utils_1.withDefault)(l[i], 0)))));
                 }
                 for (let y = 0; y < numRows; y++) {
                     indentIfNeeded();
-                    const row = Support_1.defined(t[y]);
-                    const rowWidths = Support_1.defined(widths[y]);
+                    const row = (0, Support_1.defined)(t[y]);
+                    const rowWidths = (0, Support_1.defined)(widths[y]);
                     for (let x = 0; x < numColumns; x++) {
                         const colWidth = columnWidths[x];
-                        const src = collection_utils_1.withDefault(row[x], { kind: "text", text: "" });
-                        const srcWidth = collection_utils_1.withDefault(rowWidths[x], 0);
+                        const src = (0, collection_utils_1.withDefault)(row[x], { kind: "text", text: "" });
+                        const srcWidth = (0, collection_utils_1.withDefault)(rowWidths[x], 0);
                         serializeToStringArray(src);
                         if (x < numColumns - 1 && srcWidth < colWidth) {
-                            currentLine.push(Strings_1.repeatString(" ", colWidth - srcWidth));
+                            currentLine.push((0, Strings_1.repeatString)(" ", colWidth - srcWidth));
                         }
                     }
                     if (y < numRows - 1) {
@@ -157,18 +158,18 @@ function serializeRenderResult(rootSource, names, indentation) {
                 annotations.push({ annotation: source.annotation, span: { start, end } });
                 break;
             case "name":
-                Support_1.assert(names.has(source.named), "No name for Named");
+                (0, Support_1.assert)(names.has(source.named), "No name for Named");
                 indentIfNeeded();
-                currentLine.push(Support_1.defined(names.get(source.named)));
+                currentLine.push((0, Support_1.defined)(names.get(source.named)));
                 break;
             case "modified":
                 indentIfNeeded();
                 const serialized = serializeRenderResult(source.source, names, indentation).lines;
-                Support_1.assert(serialized.length === 1, "Cannot modify more than one line.");
+                (0, Support_1.assert)(serialized.length === 1, "Cannot modify more than one line.");
                 currentLine.push(source.modifier(serialized[0]));
                 break;
             default:
-                return Support_1.assertNever(source);
+                return (0, Support_1.assertNever)(source);
         }
     }
     serializeToStringArray(rootSource);
@@ -181,7 +182,7 @@ function singleWord(...source) {
 }
 exports.singleWord = singleWord;
 function multiWord(separator, ...words) {
-    Support_1.assert(words.length > 0, "Zero words is not multiple");
+    (0, Support_1.assert)(words.length > 0, "Zero words is not multiple");
     if (words.length === 1) {
         return singleWord(words[0]);
     }

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

@@ -5,30 +5,30 @@ import { SerializedRenderResult } from "./Source";
 import { StringTypeMapping } from "./TypeBuilder";
 import { Type } from "./Type";
 import { DateTimeRecognizer } from "./DateTime";
-export declare type MultiFileRenderResult = ReadonlyMap<string, SerializedRenderResult>;
+export type MultiFileRenderResult = ReadonlyMap<string, SerializedRenderResult>;
 export declare abstract class TargetLanguage {
     readonly displayName: string;
     readonly names: string[];
     readonly extension: string;
     constructor(displayName: string, names: string[], extension: string);
     protected abstract getOptions(): Option<any>[];
-    readonly optionDefinitions: OptionDefinition[];
-    readonly cliOptionDefinitions: {
+    get optionDefinitions(): OptionDefinition[];
+    get cliOptionDefinitions(): {
         display: OptionDefinition[];
         actual: OptionDefinition[];
     };
-    readonly name: string;
+    get name(): string;
     protected abstract makeRenderer(renderContext: RenderContext, optionValues: {
         [name: string]: any;
     }): Renderer;
     renderGraphAndSerialize(typeGraph: TypeGraph, givenOutputFilename: string, alphabetizeProperties: boolean, leadingComments: string[] | undefined, rendererOptions: {
         [name: string]: any;
     }, indentation?: string): MultiFileRenderResult;
-    protected readonly defaultIndentation: string;
-    readonly stringTypeMapping: StringTypeMapping;
-    readonly supportsOptionalClassProperties: boolean;
-    readonly supportsUnionsWithBothNumberTypes: boolean;
-    readonly supportsFullObjectType: boolean;
+    protected get defaultIndentation(): string;
+    get stringTypeMapping(): StringTypeMapping;
+    get supportsOptionalClassProperties(): boolean;
+    get supportsUnionsWithBothNumberTypes(): boolean;
+    get supportsFullObjectType(): boolean;
     needsTransformerForType(_t: Type): boolean;
-    readonly dateTimeRecognizer: DateTimeRecognizer;
+    get dateTimeRecognizer(): DateTimeRecognizer;
 }

package/dist/quicktype-core/TargetLanguage.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetLanguage = void 0;
 const collection_utils_1 = require("collection-utils");
 const Source_1 = require("./Source");
 const Support_1 = require("./support/Support");
 const DateTime_1 = require("./DateTime");
 class TargetLanguage {
+    displayName;
+    names;
+    extension;
     constructor(displayName, names, extension) {
         this.displayName = displayName;
         this.names = names;
@@ -23,7 +27,7 @@ class TargetLanguage {
         return { actual, display };
     }
     get name() {
-        return Support_1.defined(this.names[0]);
+        return (0, Support_1.defined)(this.names[0]);
     }
     renderGraphAndSerialize(typeGraph, givenOutputFilename, alphabetizeProperties, leadingComments, rendererOptions, indentation) {
         if (indentation === undefined) {
@@ -35,7 +39,7 @@ class TargetLanguage {
             renderer.setAlphabetizeProperties(alphabetizeProperties);
         }
         const renderResult = renderer.render(givenOutputFilename);
-        return collection_utils_1.mapMap(renderResult.sources, s => Source_1.serializeRenderResult(s, renderResult.names, Support_1.defined(indentation)));
+        return (0, collection_utils_1.mapMap)(renderResult.sources, s => (0, Source_1.serializeRenderResult)(s, renderResult.names, (0, Support_1.defined)(indentation)));
     }
     get defaultIndentation() {
         return "    ";