quicktype-core 7.0.10 → 7.0.11

package/dist/Transformers.js

@@ -731,9 +731,7 @@ 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,10 +80,7 @@ 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) {
@@ -1020,10 +1017,7 @@ 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,12 +22,30 @@ 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"),
@@ -56,7 +74,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") {
@@ -77,7 +95,7 @@ class CPlusPlusTargetLanguage extends TargetLanguage_1.TargetLanguage {
             exports.cPlusPlusOptions.enumeratorNamingStyle,
             exports.cPlusPlusOptions.enumType,
             exports.cPlusPlusOptions.boost,
-            exports.cPlusPlusOptions.hideNullOptional,
+            exports.cPlusPlusOptions.hideNullOptional
         ];
     }
     get supportsUnionsWithBothNumberTypes() {
@@ -304,7 +322,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("], [")"]), "", "");
             }
@@ -314,8 +332,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;
@@ -398,7 +416,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;
@@ -541,10 +559,7 @@ 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"]);
             }
@@ -664,10 +679,12 @@ 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)
@@ -676,7 +693,8 @@ 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;
@@ -686,10 +704,16 @@ 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";
@@ -701,10 +725,7 @@ 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";
@@ -725,12 +746,7 @@ 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
@@ -834,7 +850,8 @@ 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; }");
@@ -867,15 +884,26 @@ 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)]),
+                        ")"
+                    ],
                 ")"
             ]);
         });
@@ -936,7 +964,11 @@ 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,
+                        ">()"
+                    ]),
                     ";"
                 ]);
             });
@@ -976,7 +1008,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];
@@ -986,7 +1018,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                             set.add(t);
                             return [true, set];
                         }
-                    }();
+                    })();
                     if (nullOrOptional) {
                         cppType = this.cppTypeInOptional(typeSet, {
                             needsForwardIndirection: false,
@@ -1045,7 +1077,11 @@ 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);
                     });
                 }
@@ -1159,7 +1195,14 @@ 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, "},");
                     });
@@ -1306,7 +1349,15 @@ 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([")"]), ");");
             });
@@ -1317,12 +1368,38 @@ 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();
@@ -1343,24 +1420,28 @@ 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,30 +78,33 @@ 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() {
@@ -116,7 +119,7 @@ class CSharpTargetLanguage extends TargetLanguage_1.TargetLanguage {
             exports.cSharpOptions.useList,
             exports.cSharpOptions.useDecimal,
             exports.cSharpOptions.typeForAny,
-            exports.cSharpOptions.virtual,
+            exports.cSharpOptions.virtual
         ];
     }
     get stringTypeMapping() {
@@ -200,9 +203,9 @@ class CSharpRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 "Equals",
                 "GetType",
                 "MemberwiseClone",
-                "ReferenceEquals",
+                "ReferenceEquals"
             ],
-            includeGlobalForbidden: false,
+            includeGlobalForbidden: false
         };
     }
     forbiddenForUnionMembers(_, unionNamed) {
@@ -239,7 +242,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, ">"];
@@ -247,12 +250,16 @@ 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);
@@ -362,9 +369,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) => {
@@ -378,7 +385,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);
@@ -475,13 +482,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) {
@@ -504,7 +511,7 @@ class NewtonsoftCSharpRenderer extends CSharpRenderer {
             "MetadataPropertyHandling",
             "DateParseHandling",
             "FromJson",
-            "Required",
+            "Required"
         ];
         if (this._options.dense) {
             forbidden.push("J", "R", "N");
@@ -527,12 +534,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];
     }
@@ -672,7 +679,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);
@@ -765,7 +772,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();");
             });
@@ -819,7 +826,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) {
@@ -1037,7 +1044,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, '"']);
                 }
@@ -1084,13 +1091,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) {
@@ -1567,7 +1574,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,7 +13,10 @@ 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")
 };