quicktype-core 7.0.13 → 7.0.15

package/dist/Transformers.js

@@ -731,7 +731,9 @@ class MinMaxValueTransformer extends ProducerTransformer {
     equals(other) {
         if (!super.equals(other))
             return false;
-        return (other instanceof MinMaxValueTransformer && this.minimum === other.minimum && this.maximum === other.maximum);
+        return (other instanceof MinMaxValueTransformer &&
+            this.minimum === other.minimum &&
+            this.maximum === other.maximum);
     }
 }
 exports.MinMaxValueTransformer = MinMaxValueTransformer;

package/dist/input/JSONSchemaInput.js

@@ -80,7 +80,10 @@ function normalizeURI(uri) {
     if (typeof uri === "string") {
         uri = new URI(uri);
     }
-    return new URI(URI.decode(uri.clone().normalize().toString()));
+    return new URI(URI.decode(uri
+        .clone()
+        .normalize()
+        .toString()));
 }
 class Ref {
     constructor(addressURI, path) {
@@ -1017,7 +1020,10 @@ class JSONSchemaInput {
         else {
             normalizedURIs = uris.map(uri => {
                 const normalizedURI = normalizeURI(uri);
-                if (normalizedURI.clone().hash("").toString() === "") {
+                if (normalizedURI
+                    .clone()
+                    .hash("")
+                    .toString() === "") {
                     normalizedURI.path(name);
                 }
                 return normalizedURI;

package/dist/language/All.js

@@ -40,7 +40,7 @@ exports.all = [
     new Dart_1.DartTargetLanguage(),
     new Python_1.PythonTargetLanguage("Python", ["python", "py"], "py"),
     new Pike_1.PikeTargetLanguage(),
-    new Haskell_1.HaskellTargetLanguage()
+    new Haskell_1.HaskellTargetLanguage(),
 ];
 function languageNamed(name, targetLanguages) {
     if (targetLanguages === undefined) {

package/dist/language/CPlusPlus.js

@@ -22,30 +22,12 @@ const upperUnderscoreValue = ["upper-underscore-case", "upper-underscore"];
 const pascalUpperAcronymsValue = ["pascal-case-upper-acronyms", "pascal-upper-acronyms"];
 const camelUpperAcronymsValue = ["camel-case-upper-acronyms", "camel-upper-acronyms"];
 exports.cPlusPlusOptions = {
-    typeSourceStyle: new RendererOptions_1.EnumOption("source-style", "Source code generation type,  whether to generate single or multiple source files", [
-        ["single-source", true],
-        ["multi-source", false]
-    ], "single-source", "secondary"),
-    includeLocation: new RendererOptions_1.EnumOption("include-location", "Whether json.hpp is to be located globally or locally", [
-        ["local-include", true],
-        ["global-include", false]
-    ], "local-include", "secondary"),
-    codeFormat: new RendererOptions_1.EnumOption("code-format", "Generate classes with getters/setters, instead of structs", [
-        ["with-struct", false],
-        ["with-getter-setter", true]
-    ], "with-getter-setter"),
-    wstring: new RendererOptions_1.EnumOption("wstring", "Store strings using Utf-16 std::wstring, rather than Utf-8 std::string", [
-        ["use-string", false],
-        ["use-wstring", true]
-    ], "use-string"),
-    msbuildPermissive: new RendererOptions_1.EnumOption("msbuildPermissive", "Moves to_json and from_json types into the nlohmann::details namespace, so that msbuild can build it with conformance mode disabled", [
-        ["not-permissive", false],
-        ["use-permissive", true]
-    ], "not-permissive", "secondary"),
-    westConst: new RendererOptions_1.EnumOption("const-style", "Put const to the left/west (const T) or right/east (T const)", [
-        ["west-const", true],
-        ["east-const", false]
-    ], "west-const"),
+    typeSourceStyle: new RendererOptions_1.EnumOption("source-style", "Source code generation type,  whether to generate single or multiple source files", [["single-source", true], ["multi-source", false]], "single-source", "secondary"),
+    includeLocation: new RendererOptions_1.EnumOption("include-location", "Whether json.hpp is to be located globally or locally", [["local-include", true], ["global-include", false]], "local-include", "secondary"),
+    codeFormat: new RendererOptions_1.EnumOption("code-format", "Generate classes with getters/setters, instead of structs", [["with-struct", false], ["with-getter-setter", true]], "with-getter-setter"),
+    wstring: new RendererOptions_1.EnumOption("wstring", "Store strings using Utf-16 std::wstring, rather than Utf-8 std::string", [["use-string", false], ["use-wstring", true]], "use-string"),
+    msbuildPermissive: new RendererOptions_1.EnumOption("msbuildPermissive", "Moves to_json and from_json types into the nlohmann::details namespace, so that msbuild can build it with conformance mode disabled", [["not-permissive", false], ["use-permissive", true]], "not-permissive", "secondary"),
+    westConst: new RendererOptions_1.EnumOption("const-style", "Put const to the left/west (const T) or right/east (T const)", [["west-const", true], ["east-const", false]], "west-const"),
     justTypes: new RendererOptions_1.BooleanOption("just-types", "Plain types only", false),
     namespace: new RendererOptions_1.StringOption("namespace", "Name of the generated namespace(s)", "NAME", "quicktype"),
     enumType: new RendererOptions_1.StringOption("enum-type", "Type of enum class", "NAME", "int", "secondary"),
@@ -74,7 +56,7 @@ exports.cPlusPlusOptions = {
         camelUpperAcronymsValue
     ]),
     boost: new RendererOptions_1.BooleanOption("boost", "Require a dependency on boost. Without boost, C++17 is required", true),
-    hideNullOptional: new RendererOptions_1.BooleanOption("hide-null-optional", "Hide null value for optional field", false)
+    hideNullOptional: new RendererOptions_1.BooleanOption("hide-null-optional", "Hide null value for optional field", false),
 };
 class CPlusPlusTargetLanguage extends TargetLanguage_1.TargetLanguage {
     constructor(displayName = "C++", names = ["c++", "cpp", "cplusplus"], extension = "cpp") {
@@ -95,7 +77,7 @@ class CPlusPlusTargetLanguage extends TargetLanguage_1.TargetLanguage {
             exports.cPlusPlusOptions.enumeratorNamingStyle,
             exports.cPlusPlusOptions.enumType,
             exports.cPlusPlusOptions.boost,
-            exports.cPlusPlusOptions.hideNullOptional
+            exports.cPlusPlusOptions.hideNullOptional,
         ];
     }
     get supportsUnionsWithBothNumberTypes() {
@@ -322,7 +304,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         super(targetLanguage, renderContext);
         this._options = _options;
         this._gettersAndSettersForPropertyName = new Map();
-        this.NarrowString = new (class extends BaseString {
+        this.NarrowString = new class extends BaseString {
             constructor() {
                 super("std::string", "const std::string & ", "std::smatch", "std::regex", "", new WrappingCode(["std::to_string("], [")"]), "", "");
             }
@@ -332,8 +314,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             emitHelperFunctions() {
                 return;
             }
-        })();
-        this.WideString = new (class extends BaseString {
+        }();
+        this.WideString = new class extends BaseString {
             constructor(superThis) {
                 super("std::wstring", "const std::wstring & ", "std::wsmatch", "std::wregex", "L", new WrappingCode(["std::to_wstring("], [")"]), "Utf16_Utf8", "convert");
                 this.superThis = superThis;
@@ -416,7 +398,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 });
                 this.superThis.ensureBlankLine();
             }
-        })(this);
+        }(this);
         this._enumType = _options.enumType;
         this._namespaceNames = _options.namespace.split("::");
         this.typeNamingStyle = _options.typeNamingStyle;
@@ -559,7 +541,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitCommentLines(this.leadingComments);
         }
         else if (!this._options.justTypes) {
-            this.emitCommentLines([" To parse this JSON data, first install", ""]);
+            this.emitCommentLines([
+                " To parse this JSON data, first install",
+                "",
+            ]);
             if (this._options.boost) {
                 this.emitCommentLines(["     Boost     http://www.boost.org"]);
             }
@@ -679,12 +664,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return [optionalType, "<", variant, ">"];
     }
     ourQualifier(inJsonNamespace) {
-        return inJsonNamespace || this._options.msbuildPermissive
-            ? [collection_utils_1.arrayIntercalate("::", this._namespaceNames), "::"]
-            : [];
+        return (inJsonNamespace || this._options.msbuildPermissive) ? [collection_utils_1.arrayIntercalate("::", this._namespaceNames), "::"] : [];
     }
     jsonQualifier(inJsonNamespace) {
-        return inJsonNamespace || this._options.msbuildPermissive ? [] : "nlohmann::";
+        return (inJsonNamespace || this._options.msbuildPermissive) ? [] : "nlohmann::";
     }
     variantIndirection(needIndirection, typeSrc) {
         if (!needIndirection)
@@ -693,8 +676,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     cppType(t, ctx, withIssues, forceNarrowString, isOptional) {
         const inJsonNamespace = ctx.inJsonNamespace;
-        if (isOptional && t instanceof Type_1.UnionType) {
-            // avoid have optionalType<optionalType<Type>>
+        if (isOptional && t instanceof Type_1.UnionType) { // avoid have optionalType<optionalType<Type>>
             for (const tChild of t.getChildren()) {
                 if (tChild.isNullable) {
                     isOptional = false;
@@ -704,16 +686,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
         let typeSource = TypeUtils_1.matchType(t, _anyType => {
             isOptional = false;
-            return Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, [
-                this.jsonQualifier(inJsonNamespace),
-                "json"
-            ]);
+            return Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, [this.jsonQualifier(inJsonNamespace), "json"]);
         }, _nullType => {
             isOptional = false;
-            return Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, [
-                this.jsonQualifier(inJsonNamespace),
-                "json"
-            ]);
+            return Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, [this.jsonQualifier(inJsonNamespace), "json"]);
         }, _boolType => "bool", _integerType => "int64_t", _doubleType => "double", _stringType => {
             if (forceNarrowString) {
                 return "std::string";
@@ -725,7 +701,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             "std::vector<",
             this.cppType(arrayType.items, { needsForwardIndirection: false, needsOptionalIndirection: true, inJsonNamespace }, withIssues, forceNarrowString, false),
             ">"
-        ], classType => this.variantIndirection(ctx.needsForwardIndirection && this.isForwardDeclaredType(classType) && !isOptional, [this.ourQualifier(inJsonNamespace), this.nameForNamedType(classType)]), mapType => {
+        ], classType => this.variantIndirection(ctx.needsForwardIndirection && this.isForwardDeclaredType(classType) && !isOptional, [
+            this.ourQualifier(inJsonNamespace),
+            this.nameForNamedType(classType)
+        ]), mapType => {
             let keyType = this._stringType.getType();
             if (forceNarrowString) {
                 keyType = "std::string";
@@ -746,7 +725,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         });
         if (!isOptional)
             return typeSource;
-        return [optionalType, "<", typeSource, ">"];
+        return [
+            optionalType,
+            "<",
+            typeSource,
+            ">"
+        ];
     }
     /**
      * similar to cppType, it practically gathers all the generated types within
@@ -850,8 +834,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                  * a member called 'value' value = value will screw up the compiler
                  */
                 const checkConst = this.lookupGlobalName(GlobalNames.CheckConstraint);
-                if ((property.type instanceof Type_1.UnionType && property.type.findMember("null") !== undefined) ||
-                    (property.isOptional && property.type.kind !== "null" && property.type.kind !== "any")) {
+                if ((property.type instanceof Type_1.UnionType && property.type.findMember("null") !== undefined) || (property.isOptional && property.type.kind !== "null" && property.type.kind !== "any")) {
                     this.emitLine(rendered, " ", getterName, "() const { return ", name, "; }");
                     if (constraints !== undefined && constraints.has(jsonName)) {
                         this.emitLine("void ", setterName, "(", rendered, " value) { if (value) ", checkConst, "(", this._stringType.createStringLiteral([name]), ", ", this.constraintMember(jsonName), ", *value); this->", name, " = value; }");
@@ -884,26 +867,15 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             res.set(jsonName, [
                 this.constraintMember(jsonName),
                 "(",
-                minMax !== undefined && minMax[0] !== undefined ? String(minMax[0]) : this._nulloptType,
+                (minMax !== undefined && minMax[0] !== undefined) ? String(minMax[0]) : this._nulloptType,
                 ", ",
-                minMax !== undefined && minMax[1] !== undefined ? String(minMax[1]) : this._nulloptType,
+                (minMax !== undefined && minMax[1] !== undefined) ? String(minMax[1]) : this._nulloptType,
                 ", ",
-                minMaxLength !== undefined && minMaxLength[0] !== undefined
-                    ? String(minMaxLength[0])
-                    : this._nulloptType,
+                (minMaxLength !== undefined && minMaxLength[0] !== undefined) ? String(minMaxLength[0]) : this._nulloptType,
                 ", ",
-                minMaxLength !== undefined && minMaxLength[1] !== undefined
-                    ? String(minMaxLength[1])
-                    : this._nulloptType,
+                (minMaxLength !== undefined && minMaxLength[1] !== undefined) ? String(minMaxLength[1]) : this._nulloptType,
                 ", ",
-                pattern === undefined
-                    ? this._nulloptType
-                    : [
-                        this._stringType.getType(),
-                        "(",
-                        this._stringType.createStringLiteral([Strings_1.stringEscape(pattern)]),
-                        ")"
-                    ],
+                (pattern === undefined) ? this._nulloptType : [this._stringType.getType(), "(", this._stringType.createStringLiteral([Strings_1.stringEscape(pattern)]), ")"],
                 ")"
             ]);
         });
@@ -964,11 +936,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, false);
                 this.emitLine([
                     "x = ",
-                    this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, [
-                        "j.get<",
-                        cppType,
-                        ">()"
-                    ]),
+                    this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, ["j.get<", cppType, ">()"]),
                     ";"
                 ]);
             });
@@ -1008,7 +976,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     return;
                 }
                 if (p.isOptional || t instanceof Type_1.UnionType) {
-                    const [nullOrOptional, typeSet] = (function () {
+                    const [nullOrOptional, typeSet] = function () {
                         if (t instanceof Type_1.UnionType) {
                             const [maybeNull, nonNulls] = TypeUtils_1.removeNullFromUnion(t, true);
                             return [maybeNull !== null || p.isOptional, nonNulls];
@@ -1018,7 +986,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                             set.add(t);
                             return [true, set];
                         }
-                    })();
+                    }();
                     if (nullOrOptional) {
                         cppType = this.cppTypeInOptional(typeSet, {
                             needsForwardIndirection: false,
@@ -1077,11 +1045,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     ";"
                 ];
                 if (p.isOptional && this._options.hideNullOptional) {
-                    this.emitBlock([
-                        "if (",
-                        this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, ["x.", getter]),
-                        ")"
-                    ], false, () => {
+                    this.emitBlock(["if (", this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, ["x.", getter]), ")"], false, () => {
                         this.emitLine(assignment);
                     });
                 }
@@ -1195,14 +1159,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         const ourQualifier = this.ourQualifier(true);
         this.emitBlock(["inline void from_json(", this.withConst("json"), " & j, ", ourQualifier, enumName, " & x)"], false, () => {
             if (this.isLargeEnum(e)) {
-                this.emitBlock([
-                    "static std::unordered_map<",
-                    this._stringType.getType(),
-                    ", ",
-                    ourQualifier,
-                    enumName,
-                    "> enumValues"
-                ], true, () => {
+                this.emitBlock(["static std::unordered_map<", this._stringType.getType(), ", ", ourQualifier, enumName, "> enumValues"], true, () => {
                     this.forEachEnumCase(e, "none", (name, jsonName) => {
                         this.emitLine("{", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(jsonName)])]), ", ", ourQualifier, enumName, "::", name, "},");
                     });
@@ -1349,15 +1306,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.ensureBlankLine();
         }
         const checkConst = this.lookupGlobalName(GlobalNames.CheckConstraint);
-        this.emitBlock([
-            "inline void ",
-            checkConst,
-            "(",
-            this._stringType.getConstType(),
-            " name, ",
-            this.withConst(classConstraint),
-            " & c, int64_t value)"
-        ], false, () => {
+        this.emitBlock(["inline void ", checkConst, "(", this._stringType.getConstType(), " name, ", this.withConst(classConstraint), " & c, int64_t value)"], false, () => {
             this.emitBlock(["if (c.", getterMinValue, "() != ", this._nulloptType, " && value < *c.", getterMinValue, "())"], false, () => {
                 this.emitLine("throw ", this.lookupGlobalName(GlobalNames.ValueTooLowException), " (", this._stringType.createStringLiteral(["Value too low for "]), " + name + ", this._stringType.createStringLiteral([" ("]), " + ", this._stringType.wrapToString(["value"]), " + ", this._stringType.createStringLiteral(["<"]), " + ", this._stringType.wrapToString(["*c.", getterMinValue, "()"]), " + ", this._stringType.createStringLiteral([")"]), ");");
             });
@@ -1368,38 +1317,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.ensureBlankLine();
         });
         this.ensureBlankLine();
-        this.emitBlock([
-            "inline void ",
-            checkConst,
-            "(",
-            this._stringType.getConstType(),
-            " name, ",
-            this.withConst(classConstraint),
-            " & c, ",
-            this._stringType.getConstType(),
-            " value)"
-        ], false, () => {
-            this.emitBlock([
-                "if (c.",
-                getterMinLength,
-                "() != ",
-                this._nulloptType,
-                " && value.length() < *c.",
-                getterMinLength,
-                "())"
-            ], false, () => {
+        this.emitBlock(["inline void ", checkConst, "(", this._stringType.getConstType(), " name, ", this.withConst(classConstraint), " & c, ", this._stringType.getConstType(), " value)"], false, () => {
+            this.emitBlock(["if (c.", getterMinLength, "() != ", this._nulloptType, " && value.length() < *c.", getterMinLength, "())"], false, () => {
                 this.emitLine("throw ", this.lookupGlobalName(GlobalNames.ValueTooShortException), " (", this._stringType.createStringLiteral(["Value too short for "]), " + name + ", this._stringType.createStringLiteral([" ("]), " + ", this._stringType.wrapToString(["value.length()"]), " + ", this._stringType.createStringLiteral(["<"]), " + ", this._stringType.wrapToString(["*c.", getterMinLength, "()"]), " + ", this._stringType.createStringLiteral([")"]), ");");
             });
             this.ensureBlankLine();
-            this.emitBlock([
-                "if (c.",
-                getterMaxLength,
-                "() != ",
-                this._nulloptType,
-                " && value.length() > *c.",
-                getterMaxLength,
-                "())"
-            ], false, () => {
+            this.emitBlock(["if (c.", getterMaxLength, "() != ", this._nulloptType, " && value.length() > *c.", getterMaxLength, "())"], false, () => {
                 this.emitLine("throw ", this.lookupGlobalName(GlobalNames.ValueTooLongException), " (", this._stringType.createStringLiteral(["Value too long for "]), " + name + ", this._stringType.createStringLiteral([" ("]), " + ", this._stringType.wrapToString(["value.length()"]), " + ", this._stringType.createStringLiteral([">"]), " + ", this._stringType.wrapToString(["*c.", getterMaxLength, "()"]), " + ", this._stringType.createStringLiteral([")"]), ");");
             });
             this.ensureBlankLine();
@@ -1420,28 +1343,24 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitConstraintClasses();
             this.ensureBlankLine();
         }
-        this.emitBlock(["inline json get_untyped(", this.withConst("json"), " & j, ", this.withConst("char"), " * property)"], false, () => {
+        this.emitBlock([
+            "inline json get_untyped(", this.withConst("json"), " & j, ", this.withConst("char"), " * property)"
+        ], false, () => {
             this.emitBlock(["if (j.find(property) != j.end())"], false, () => {
                 this.emitLine("return j.at(property).get<json>();");
             });
             this.emitLine("return json();");
         });
         this.ensureBlankLine();
-        this.emitBlock(["inline json get_untyped(", this.withConst("json"), " & j, std::string property)"], false, () => {
+        this.emitBlock([
+            "inline json get_untyped(", this.withConst("json"), " & j, std::string property)"
+        ], false, () => {
             this.emitLine("return get_untyped(j, property.data());");
         });
         this.ensureBlankLine();
         if (this.haveUnions || this.haveOptionalProperties) {
             this.emitLine("template <typename T>");
-            this.emitBlock([
-                "inline ",
-                optionalType,
-                "<T> get_optional(",
-                this.withConst("json"),
-                " & j, ",
-                this.withConst("char"),
-                " * property)"
-            ], false, () => {
+            this.emitBlock(["inline ", optionalType, "<T> get_optional(", this.withConst("json"), " & j, ", this.withConst("char"), " * property)"], false, () => {
                 this.emitBlock(["if (j.find(property) != j.end())"], false, () => {
                     this.emitLine("return j.at(property).get<", optionalType, "<T>>();");
                 });

package/dist/language/CSharp.js

@@ -78,33 +78,30 @@ function csTypeForTransformedStringType(t) {
     }
 }
 exports.cSharpOptions = {
-    framework: new RendererOptions_1.EnumOption("framework", "Serialization framework", [
-        ["NewtonSoft", Framework.Newtonsoft],
-        ["SystemTextJson", Framework.SystemTextJson]
-    ], "NewtonSoft"),
+    framework: new RendererOptions_1.EnumOption("framework", "Serialization framework", [["NewtonSoft", Framework.Newtonsoft], ["SystemTextJson", Framework.SystemTextJson]], "NewtonSoft"),
     useList: new RendererOptions_1.EnumOption("array-type", "Use T[] or List<T>", [
         ["array", false],
-        ["list", true]
+        ["list", true],
     ]),
     dense: new RendererOptions_1.EnumOption("density", "Property density", [
         ["normal", false],
-        ["dense", true]
+        ["dense", true],
     ], "normal", "secondary"),
     // FIXME: Do this via a configurable named eventually.
     namespace: new RendererOptions_1.StringOption("namespace", "Generated namespace", "NAME", "QuickType"),
     version: new RendererOptions_1.EnumOption("csharp-version", "C# version", [
         ["5", 5],
-        ["6", 6]
+        ["6", 6],
     ], "6", "secondary"),
     virtual: new RendererOptions_1.BooleanOption("virtual", "Generate virtual properties", false),
     typeForAny: new RendererOptions_1.EnumOption("any-type", 'Type to use for "any"', [
         ["object", "object"],
-        ["dynamic", "dynamic"]
+        ["dynamic", "dynamic"],
     ], "object", "secondary"),
     useDecimal: new RendererOptions_1.EnumOption("number-type", "Type to use for numbers", [
         ["double", false],
-        ["decimal", true]
-    ], "double", "secondary")
+        ["decimal", true],
+    ], "double", "secondary"),
 };
 class CSharpTargetLanguage extends TargetLanguage_1.TargetLanguage {
     constructor() {
@@ -119,7 +116,7 @@ class CSharpTargetLanguage extends TargetLanguage_1.TargetLanguage {
             exports.cSharpOptions.useList,
             exports.cSharpOptions.useDecimal,
             exports.cSharpOptions.typeForAny,
-            exports.cSharpOptions.virtual
+            exports.cSharpOptions.virtual,
         ];
     }
     get stringTypeMapping() {
@@ -203,9 +200,9 @@ class CSharpRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 "Equals",
                 "GetType",
                 "MemberwiseClone",
-                "ReferenceEquals"
+                "ReferenceEquals",
             ],
-            includeGlobalForbidden: false
+            includeGlobalForbidden: false,
         };
     }
     forbiddenForUnionMembers(_, unionNamed) {
@@ -242,7 +239,7 @@ class CSharpRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     csType(t, follow = Transformers_1.followTargetType, withIssues = false) {
         const actualType = follow(t);
-        return TypeUtils_1.matchType(actualType, _anyType => Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, this._csOptions.typeForAny), _nullType => Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, this._csOptions.typeForAny), _boolType => "bool", _integerType => "long", _doubleType => this.doubleType, _stringType => "string", arrayType => {
+        return TypeUtils_1.matchType(actualType, (_anyType) => Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, this._csOptions.typeForAny), (_nullType) => Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, this._csOptions.typeForAny), (_boolType) => "bool", (_integerType) => "long", (_doubleType) => this.doubleType, (_stringType) => "string", (arrayType) => {
             const itemsType = this.csType(arrayType.items, follow, withIssues);
             if (this._csOptions.useList) {
                 return ["System.Collections.Generic.List<", itemsType, ">"];
@@ -250,16 +247,12 @@ class CSharpRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             else {
                 return [itemsType, "[]"];
             }
-        }, classType => this.nameForNamedType(classType), mapType => [
-            "System.Collections.Generic.Dictionary<string, ",
-            this.csType(mapType.values, follow, withIssues),
-            ">"
-        ], enumType => this.nameForNamedType(enumType), unionType => {
+        }, (classType) => this.nameForNamedType(classType), (mapType) => ["System.Collections.Generic.Dictionary<string, ", this.csType(mapType.values, follow, withIssues), ">"], (enumType) => this.nameForNamedType(enumType), (unionType) => {
             const nullable = TypeUtils_1.nullableFromUnion(unionType);
             if (nullable !== null)
                 return this.nullableCSType(nullable, noFollow);
             return this.nameForNamedType(unionType);
-        }, transformedStringType => csTypeForTransformedStringType(transformedStringType));
+        }, (transformedStringType) => csTypeForTransformedStringType(transformedStringType));
     }
     nullableCSType(t, follow = Transformers_1.followTargetType, withIssues = false) {
         t = Transformers_1.followTargetType(t);
@@ -369,9 +362,9 @@ class CSharpRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 this.emitLine("public ", csType, " ", fieldName, ";");
             });
             this.ensureBlankLine();
-            const nullTests = Array.from(nonNulls).map(t => [
+            const nullTests = Array.from(nonNulls).map((t) => [
                 this.nameForUnionMember(u, t),
-                " == null"
+                " == null",
             ]);
             this.ensureBlankLine();
             this.forEachUnionMember(u, nonNulls, "none", null, (fieldName, t) => {
@@ -385,7 +378,7 @@ class CSharpRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     emitEnumDefinition(e, enumName) {
         const caseNames = [];
-        this.forEachEnumCase(e, "none", name => {
+        this.forEachEnumCase(e, "none", (name) => {
             if (caseNames.length > 0)
                 caseNames.push(", ");
             caseNames.push(name);
@@ -482,13 +475,13 @@ exports.newtonsoftCSharpOptions = Object.assign({}, exports.cSharpOptions, {
         ["complete", { namespaces: true, helpers: true, attributes: true }],
         ["attributes-only", { namespaces: true, helpers: false, attributes: true }],
         ["just-types-and-namespace", { namespaces: true, helpers: false, attributes: false }],
-        ["just-types", { namespaces: true, helpers: false, attributes: false }]
+        ["just-types", { namespaces: true, helpers: false, attributes: false }],
     ]),
     baseclass: new RendererOptions_1.EnumOption("base-class", "Base class", [
         ["EntityData", "EntityData"],
-        ["Object", undefined]
+        ["Object", undefined],
     ], "Object", "secondary"),
-    checkRequired: new RendererOptions_1.BooleanOption("check-required", "Fail if required properties are missing", false)
+    checkRequired: new RendererOptions_1.BooleanOption("check-required", "Fail if required properties are missing", false),
 });
 class NewtonsoftCSharpRenderer extends CSharpRenderer {
     constructor(targetLanguage, renderContext, _options) {
@@ -511,7 +504,7 @@ class NewtonsoftCSharpRenderer extends CSharpRenderer {
             "MetadataPropertyHandling",
             "DateParseHandling",
             "FromJson",
-            "Required"
+            "Required",
         ];
         if (this._options.dense) {
             forbidden.push("J", "R", "N");
@@ -534,12 +527,12 @@ class NewtonsoftCSharpRenderer extends CSharpRenderer {
             }
             return new Naming_1.SimpleName([`${xfer.kind}_converter`], namingFunction, ConvenienceRenderer_1.inferredNameOrder + 30);
         }
-        return new Naming_1.DependencyName(namingFunction, typeName.order + 30, lookup => `${lookup(typeName)}_converter`);
+        return new Naming_1.DependencyName(namingFunction, typeName.order + 30, (lookup) => `${lookup(typeName)}_converter`);
     }
     makeNamedTypeDependencyNames(t, name) {
         if (!(t instanceof Type_1.EnumType))
             return [];
-        const extensionsName = new Naming_1.DependencyName(namingFunction, name.order + 30, lookup => `${lookup(name)}_extensions`);
+        const extensionsName = new Naming_1.DependencyName(namingFunction, name.order + 30, (lookup) => `${lookup(name)}_extensions`);
         this._enumExtensionsNames.set(name, extensionsName);
         return [extensionsName];
     }
@@ -679,7 +672,7 @@ class NewtonsoftCSharpRenderer extends CSharpRenderer {
             // Sometimes multiple top-levels will resolve to the same type, so we have to take care
             // not to emit more than one extension method for the same type.
             const seenTypes = new Set();
-            this.forEachTopLevel("none", t => {
+            this.forEachTopLevel("none", (t) => {
                 // FIXME: Make ToJson a Named
                 if (!seenTypes.has(t)) {
                     seenTypes.add(t);
@@ -772,7 +765,7 @@ class NewtonsoftCSharpRenderer extends CSharpRenderer {
             this.emitLine("var ", variableName, " = new List<", this.csType(targetType.items), ">();");
             this.emitLine("while (reader.TokenType != JsonToken.EndArray)");
             this.emitBlock(() => {
-                this.emitDecodeTransformer(xfer.itemTransformer, xfer.itemTargetType, v => this.emitLine(variableName, ".Add(", v, ");"), "arrayItem");
+                this.emitDecodeTransformer(xfer.itemTransformer, xfer.itemTargetType, (v) => this.emitLine(variableName, ".Add(", v, ");"), "arrayItem");
                 // FIXME: handle EOF
                 this.emitLine("reader.Read();");
             });
@@ -826,7 +819,7 @@ class NewtonsoftCSharpRenderer extends CSharpRenderer {
         }
         if (xfer instanceof Transformers_1.ChoiceTransformer) {
             const caseXfers = xfer.transformers;
-            if (caseXfers.length > 1 && caseXfers.every(caseXfer => caseXfer instanceof Transformers_1.StringMatchTransformer)) {
+            if (caseXfers.length > 1 && caseXfers.every((caseXfer) => caseXfer instanceof Transformers_1.StringMatchTransformer)) {
                 this.emitLine("switch (", variable, ")");
                 this.emitBlock(() => {
                     for (const caseXfer of caseXfers) {
@@ -1044,7 +1037,7 @@ class NewtonsoftCSharpRenderer extends CSharpRenderer {
                 if (haveNullable && !(targetType instanceof Type_1.UnionType)) {
                     this.emitLine("if (reader.TokenType == JsonToken.Null) return null;");
                 }
-                const allHandled = this.emitDecodeTransformer(xfer, targetType, v => this.emitLine("return ", v, ";"));
+                const allHandled = this.emitDecodeTransformer(xfer, targetType, (v) => this.emitLine("return ", v, ";"));
                 if (!allHandled) {
                     this.emitThrow(['"Cannot unmarshal type ', csType, '"']);
                 }
@@ -1091,13 +1084,13 @@ exports.systemTextJsonCSharpOptions = Object.assign({}, exports.cSharpOptions, {
         ["complete", { namespaces: true, helpers: true, attributes: true }],
         ["attributes-only", { namespaces: true, helpers: false, attributes: true }],
         ["just-types-and-namespace", { namespaces: true, helpers: false, attributes: false }],
-        ["just-types", { namespaces: true, helpers: false, attributes: false }]
+        ["just-types", { namespaces: true, helpers: false, attributes: false }],
     ]),
     baseclass: new RendererOptions_1.EnumOption("base-class", "Base class", [
         ["EntityData", "EntityData"],
-        ["Object", undefined]
+        ["Object", undefined],
     ], "Object", "secondary"),
-    checkRequired: new RendererOptions_1.BooleanOption("check-required", "Fail if required properties are missing", false)
+    checkRequired: new RendererOptions_1.BooleanOption("check-required", "Fail if required properties are missing", false),
 });
 class SystemTextJsonCSharpRenderer extends CSharpRenderer {
     constructor(targetLanguage, renderContext, _options) {
@@ -1574,7 +1567,7 @@ class SystemTextJsonCSharpRenderer extends CSharpRenderer {
                     this.emitBlock(() => {
                         // this.emitLine("var uri = new Uri(", variable, ");");
                         // The default value about:blank should never happen, but this way we avoid a null reference warning.
-                        this.emitLine('var uri = new Uri("about:blank");');
+                        this.emitLine("var uri = new Uri(\"about:blank\");");
                         this.emitLine("if (!string.IsNullOrEmpty(stringValue))");
                         this.emitBlock(() => {
                             this.emitLine("uri = new Uri(", variable, ");");

package/dist/language/Elm.js

@@ -13,10 +13,7 @@ const Source_1 = require("../Source");
 const Annotation_1 = require("../Annotation");
 exports.elmOptions = {
     justTypes: new RendererOptions_1.BooleanOption("just-types", "Plain types only", false),
-    useList: new RendererOptions_1.EnumOption("array-type", "Use Array or List", [
-        ["array", false],
-        ["list", true]
-    ]),
+    useList: new RendererOptions_1.EnumOption("array-type", "Use Array or List", [["array", false], ["list", true]]),
     // FIXME: Do this via a configurable named eventually.
     moduleName: new RendererOptions_1.StringOption("module", "Generated module name", "NAME", "QuickType")
 };