quicktype 17.0.4 → 17.0.5

package/dist/quicktype-core/language/CPlusPlus.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CPlusPlusRenderer = exports.MemberNames = exports.GlobalNames = exports.IncludeKind = exports.CPlusPlusTargetLanguage = exports.cPlusPlusOptions = void 0;
 const collection_utils_1 = require("collection-utils");
 const TargetLanguage_1 = require("../TargetLanguage");
 const Type_1 = require("../Type");
@@ -106,19 +105,19 @@ class CPlusPlusTargetLanguage extends TargetLanguage_1.TargetLanguage {
         return true;
     }
     makeRenderer(renderContext, untypedOptionValues) {
-        return new CPlusPlusRenderer(this, renderContext, (0, RendererOptions_1.getOptionValues)(exports.cPlusPlusOptions, untypedOptionValues));
+        return new CPlusPlusRenderer(this, renderContext, RendererOptions_1.getOptionValues(exports.cPlusPlusOptions, untypedOptionValues));
     }
 }
 exports.CPlusPlusTargetLanguage = CPlusPlusTargetLanguage;
 function constraintsForType(t) {
-    const minMax = (0, Constraints_1.minMaxValueForType)(t);
-    const minMaxLength = (0, Constraints_1.minMaxLengthForType)(t);
-    const pattern = (0, Constraints_1.patternForType)(t);
+    const minMax = Constraints_1.minMaxValueForType(t);
+    const minMaxLength = Constraints_1.minMaxLengthForType(t);
+    const pattern = Constraints_1.patternForType(t);
     if (minMax === undefined && minMaxLength === undefined && pattern === undefined)
         return undefined;
     return { minMax, minMaxLength, pattern };
 }
-const legalizeName = (0, Strings_1.legalizeCharacters)(cp => (0, Strings_1.isAscii)(cp) && (0, Strings_1.isLetterOrUnderscoreOrDigit)(cp));
+const legalizeName = Strings_1.legalizeCharacters(cp => Strings_1.isAscii(cp) && Strings_1.isLetterOrUnderscoreOrDigit(cp));
 const keywords = [
     "alignas",
     "alignof",
@@ -280,8 +279,6 @@ function addQualifier(qualifier, qualified) {
     return [qualifier, qualified];
 }
 class WrappingCode {
-    _start;
-    _end;
     constructor(start, end) {
         this._start = start;
         this._end = end;
@@ -291,14 +288,6 @@ class WrappingCode {
     }
 }
 class BaseString {
-    _stringType;
-    _constStringType;
-    _smatch;
-    _regex;
-    _stringLiteralPrefix;
-    _toString;
-    _encodingClass;
-    _encodingFunction;
     constructor(stringType, constStringType, smatch, regex, stringLiteralPrefix, toString, encodingClass, encodingFunction) {
         (this._stringType = stringType),
             (this._constStringType = constStringType),
@@ -329,39 +318,112 @@ class BaseString {
     }
 }
 class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
-    _options;
-    /**
-     * For forward declaration practically
-     */
-    _enumType;
-    _generatedFiles;
-    _currentFilename;
-    _allTypeNames;
-    _gettersAndSettersForPropertyName = new Map();
-    _namespaceNames;
-    _memberNameStyle;
-    _namedTypeNameStyle;
-    _generatedGlobalNames;
-    _generatedMemberNames;
-    _forbiddenGlobalNames;
-    _memberNamingFunction;
-    _stringType;
-    _optionalType;
-    _nulloptType;
-    _variantType;
-    _variantIndexMethodName;
-    typeNamingStyle;
-    enumeratorNamingStyle;
     constructor(targetLanguage, renderContext, _options) {
         super(targetLanguage, renderContext);
         this._options = _options;
+        this._gettersAndSettersForPropertyName = new Map();
+        this.NarrowString = new (class extends BaseString {
+            constructor() {
+                super("std::string", "const std::string & ", "std::smatch", "std::regex", "", new WrappingCode(["std::to_string("], [")"]), "", "");
+            }
+            wrapEncodingChange(_qualifier, _fromType, _toType, inner) {
+                return inner;
+            }
+            emitHelperFunctions() {
+                return;
+            }
+        })();
+        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;
+            }
+            wrapEncodingChange(qualifier, fromType, toType, inner) {
+                if (this.superThis.sourcelikeToString(fromType) === this.superThis.sourcelikeToString(toType)) {
+                    return inner;
+                }
+                return [
+                    addQualifier(qualifier, [this._encodingClass]),
+                    "<",
+                    fromType,
+                    ", ",
+                    toType,
+                    ">::",
+                    this._encodingFunction,
+                    "(",
+                    inner,
+                    ")"
+                ];
+            }
+            emitHelperFunctions() {
+                this.superThis.emitLine("template<typename T>");
+                this.superThis.emitLine("struct tag {};");
+                this.superThis.ensureBlankLine();
+                this.superThis.emitLine("template<typename fromType, typename toType>");
+                this.superThis.emitBlock(["class Utf16_Utf8"], true, () => {
+                    this.superThis.emitLine("private:");
+                    this.superThis.emitLine("template<typename TF, typename TT>");
+                    this.superThis.emitBlock(["static toType convert(tag<std::shared_ptr<TF> >, tag<std::shared_ptr<TT> >, fromType ptr)"], false, () => {
+                        this.superThis.emitLine("if (ptr == nullptr) return std::unique_ptr<TT>(); else return std::unique_ptr<TT>(new TT(Utf16_Utf8<TF,TT>::convert(*ptr)));");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitLine("template<typename TF, typename TT>");
+                    this.superThis.emitBlock(["static toType convert(tag<std::vector<TF> >, tag<std::vector<TT> >, fromType v)"], false, () => {
+                        this.superThis.emitLine("auto it = v.begin();");
+                        this.superThis.emitLine("auto newVector = std::vector<TT>();");
+                        this.superThis.emitBlock(["while (it != v.end())"], false, () => {
+                            this.superThis.emitLine("newVector.push_back(Utf16_Utf8<TF,TT>::convert(*it));");
+                            this.superThis.emitLine("it++;");
+                        });
+                        this.superThis.emitLine("return newVector;");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitLine("template<typename KF, typename VF, typename KT, typename VT>");
+                    this.superThis.emitBlock(["static toType convert(tag<std::map<KF,VF> >, tag<std::map<KT,VT> >, fromType m)"], false, () => {
+                        this.superThis.emitLine("auto it = m.begin();");
+                        this.superThis.emitLine("auto newMap = std::map<KT, VT>();");
+                        this.superThis.emitBlock(["while (it != m.end())"], false, () => {
+                            this.superThis.emitLine("newMap.insert(std::pair<KT, VT>(Utf16_Utf8<KF, KT>::convert(it->first), Utf16_Utf8<VF, VT>::convert(it->second)));");
+                            this.superThis.emitLine("it++;");
+                        });
+                        this.superThis.emitLine("return newMap;");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitLine("template<typename TF, typename TT>");
+                    this.superThis.emitBlock(["static fromType convert(tag<TF>, tag<TT>, fromType from)"], false, () => {
+                        this.superThis.emitLine("return from;");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitBlock(["static std::wstring convert(tag<std::string>, tag<std::wstring>, std::string str)"], false, () => {
+                        this.superThis.emitLine("return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t, 0x10ffff, std::little_endian>, wchar_t>{}.from_bytes(str.data());");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitBlock(["static std::string convert(tag<std::wstring>, tag<std::string>, std::wstring str)"], false, () => {
+                        this.superThis.emitLine("return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t, 0x10ffff, std::little_endian>, wchar_t>{}.to_bytes(str.data());");
+                    });
+                    this.superThis.ensureBlankLine();
+                    this.superThis.emitLine("public:");
+                    this.superThis.emitBlock(["static toType convert(fromType in)"], false, () => {
+                        this.superThis.emitLine("return convert(tag<fromType>(), tag<toType>(), in);");
+                    });
+                });
+                this.superThis.ensureBlankLine();
+                this.superThis.emitLine("template<typename T>");
+                this.superThis.emitBlock(["std::wstring wdump(const T& j)"], false, () => {
+                    this.superThis.emitLine("std::ostringstream s;");
+                    this.superThis.emitLine("s << j;");
+                    this.superThis.emitLine("return ", this.superThis.ourQualifier(false), "Utf16_Utf8<std::string, std::wstring>::convert(s.str()); ");
+                });
+                this.superThis.ensureBlankLine();
+            }
+        })(this);
         this._enumType = _options.enumType;
         this._namespaceNames = _options.namespace.split("::");
         this.typeNamingStyle = _options.typeNamingStyle;
-        this._namedTypeNameStyle = (0, Strings_1.makeNameStyle)(this.typeNamingStyle, legalizeName);
+        this._namedTypeNameStyle = Strings_1.makeNameStyle(this.typeNamingStyle, legalizeName);
         this.enumeratorNamingStyle = _options.enumeratorNamingStyle;
-        this._memberNameStyle = (0, Strings_1.makeNameStyle)(_options.memberNamingStyle, legalizeName);
-        this._memberNamingFunction = (0, Naming_1.funPrefixNamer)("members", this._memberNameStyle);
+        this._memberNameStyle = Strings_1.makeNameStyle(_options.memberNamingStyle, legalizeName);
+        this._memberNamingFunction = Naming_1.funPrefixNamer("members", this._memberNameStyle);
         this._gettersAndSettersForPropertyName = new Map();
         this._allTypeNames = new Set();
         this._generatedFiles = new Set();
@@ -424,10 +486,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         ];
     }
     lookupGlobalName(type) {
-        return (0, Support_1.defined)(this._generatedGlobalNames.get(type));
+        return Support_1.defined(this._generatedGlobalNames.get(type));
     }
     lookupMemberName(type) {
-        return (0, Support_1.defined)(this._generatedMemberNames.get(type));
+        return Support_1.defined(this._generatedMemberNames.get(type));
     }
     addGlobalName(type) {
         const genName = this._namedTypeNameStyle(GlobalNames[type]);
@@ -438,10 +500,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this._generatedMemberNames.set(type, this._memberNameStyle(MemberNames[type]));
     }
     setupGlobalNames() {
-        for (const v of (0, Support_1.numberEnumValues)(GlobalNames)) {
+        for (const v of Support_1.numberEnumValues(GlobalNames)) {
             this.addGlobalName(v);
         }
-        for (const v of (0, Support_1.numberEnumValues)(MemberNames)) {
+        for (const v of Support_1.numberEnumValues(MemberNames)) {
             this.addMemberName(v);
         }
     }
@@ -455,7 +517,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return { names: [], includeGlobalForbidden: true };
     }
     makeNamedTypeNamer() {
-        return (0, Naming_1.funPrefixNamer)("types", this._namedTypeNameStyle);
+        return Naming_1.funPrefixNamer("types", this._namedTypeNameStyle);
     }
     namerForObjectProperty() {
         return this._memberNamingFunction;
@@ -464,7 +526,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return null;
     }
     makeEnumCaseNamer() {
-        return (0, Naming_1.funPrefixNamer)("enumerators", (0, Strings_1.makeNameStyle)(this.enumeratorNamingStyle, legalizeName));
+        return Naming_1.funPrefixNamer("enumerators", Strings_1.makeNameStyle(this.enumeratorNamingStyle, legalizeName));
     }
     makeNamesForPropertyGetterAndSetter(_c, _className, _p, _jsonName, name) {
         const getterName = new Naming_1.DependencyName(this._memberNamingFunction, name.order, lookup => `get_${lookup(name)}`);
@@ -489,7 +551,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("#include ", global ? "<" : '"', name, global ? ">" : '"');
     }
     startFile(basename, includeHelper = true) {
-        (0, Support_2.assert)(this._currentFilename === undefined, "Previous file wasn't finished");
+        Support_2.assert(this._currentFilename === undefined, "Previous file wasn't finished");
         if (basename !== undefined) {
             this._currentFilename = this.sourcelikeToString(basename);
         }
@@ -549,7 +611,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.ensureBlankLine();
     }
     finishFile() {
-        super.finishFile((0, Support_1.defined)(this._currentFilename));
+        super.finishFile(Support_1.defined(this._currentFilename));
         this._currentFilename = undefined;
     }
     get needsTypeDeclarationBeforeUse() {
@@ -580,7 +642,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
     }
     emitNamespaces(namespaceNames, f) {
-        const namesArray = (0, collection_utils_1.toReadonlyArray)(namespaceNames);
+        const namesArray = collection_utils_1.toReadonlyArray(namespaceNames);
         const first = namesArray[0];
         if (first === undefined) {
             f();
@@ -591,7 +653,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     cppTypeInOptional(nonNulls, ctx, withIssues, forceNarrowString) {
         if (nonNulls.size === 1) {
-            return this.cppType((0, Support_1.defined)((0, collection_utils_1.iterableFirst)(nonNulls)), ctx, withIssues, forceNarrowString, false);
+            return this.cppType(Support_1.defined(collection_utils_1.iterableFirst(nonNulls)), ctx, withIssues, forceNarrowString, false);
         }
         const typeList = [];
         for (const t of nonNulls) {
@@ -607,8 +669,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return [this._variantType, "<", typeList, ">"];
     }
     variantType(u, inJsonNamespace) {
-        const [maybeNull, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(u, true);
-        (0, Support_2.assert)(nonNulls.size >= 2, "Variant not needed for less than two types.");
+        const [maybeNull, nonNulls] = TypeUtils_1.removeNullFromUnion(u, true);
+        Support_2.assert(nonNulls.size >= 2, "Variant not needed for less than two types.");
         const indirection = maybeNull !== null;
         const variant = this.cppTypeInOptional(nonNulls, { needsForwardIndirection: !indirection, needsOptionalIndirection: !indirection, inJsonNamespace }, true, false);
         if (!indirection) {
@@ -618,7 +680,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     ourQualifier(inJsonNamespace) {
         return inJsonNamespace || this._options.msbuildPermissive
-            ? [(0, collection_utils_1.arrayIntercalate)("::", this._namespaceNames), "::"]
+            ? [collection_utils_1.arrayIntercalate("::", this._namespaceNames), "::"]
             : [];
     }
     jsonQualifier(inJsonNamespace) {
@@ -640,15 +702,15 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 }
             }
         }
-        let typeSource = (0, TypeUtils_1.matchType)(t, _anyType => {
+        let typeSource = TypeUtils_1.matchType(t, _anyType => {
             isOptional = false;
-            return (0, Source_1.maybeAnnotated)(withIssues, Annotation_1.anyTypeIssueAnnotation, [
+            return Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, [
                 this.jsonQualifier(inJsonNamespace),
                 "json"
             ]);
         }, _nullType => {
             isOptional = false;
-            return (0, Source_1.maybeAnnotated)(withIssues, Annotation_1.nullTypeIssueAnnotation, [
+            return Source_1.maybeAnnotated(withIssues, Annotation_1.nullTypeIssueAnnotation, [
                 this.jsonQualifier(inJsonNamespace),
                 "json"
             ]);
@@ -676,7 +738,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 ">"
             ];
         }, enumType => [this.ourQualifier(inJsonNamespace), this.nameForNamedType(enumType)], unionType => {
-            const nullable = (0, TypeUtils_1.nullableFromUnion)(unionType);
+            const nullable = TypeUtils_1.nullableFromUnion(unionType);
             if (nullable === null)
                 return [this.ourQualifier(inJsonNamespace), this.nameForNamedType(unionType)];
             isOptional = true;
@@ -743,7 +805,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     });
                     /** intentional "fall-through", add all subtypes as well - but forced include */
                 }
-                const [hasNull, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(t);
+                const [hasNull, nonNulls] = TypeUtils_1.removeNullFromUnion(t);
                 isVariant = hasNull !== null;
                 /** we need to collect all the subtypes of the union */
                 for (const tt of nonNulls) {
@@ -780,7 +842,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 this.emitMember(this.cppType(property.type, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false, property.isOptional), name);
             }
             else {
-                const [getterName, mutableGetterName, setterName] = (0, Support_1.defined)(this._gettersAndSettersForPropertyName.get(name));
+                const [getterName, mutableGetterName, setterName] = Support_1.defined(this._gettersAndSettersForPropertyName.get(name));
                 const rendered = this.cppType(property.type, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false, property.isOptional);
                 /**
                  * fix for optional type -> e.g. unique_ptrs can't be copied
@@ -839,7 +901,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     : [
                         this._stringType.getType(),
                         "(",
-                        this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(pattern)]),
+                        this._stringType.createStringLiteral([Strings_1.stringEscape(pattern)]),
                         ")"
                     ],
                 ")"
@@ -927,7 +989,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         let toType;
         this.emitBlock(["inline void from_json(", this.withConst("json"), " & j, ", ourQualifier, className, "& x)"], false, () => {
             this.forEachClassProperty(c, "none", (name, json, p) => {
-                const [, , setterName] = (0, Support_1.defined)(this._gettersAndSettersForPropertyName.get(name));
+                const [, , setterName] = Support_1.defined(this._gettersAndSettersForPropertyName.get(name));
                 const t = p.type;
                 let assignment;
                 if (this._options.codeFormat) {
@@ -940,7 +1002,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     this.emitLine(assignment.wrap([], [
                         ourQualifier,
                         "get_untyped(j, ",
-                        this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])]),
+                        this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(json)])]),
                         ")"
                     ]), ";");
                     return;
@@ -948,7 +1010,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 if (p.isOptional || t instanceof Type_1.UnionType) {
                     const [nullOrOptional, typeSet] = (function () {
                         if (t instanceof Type_1.UnionType) {
-                            const [maybeNull, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(t, true);
+                            const [maybeNull, nonNulls] = TypeUtils_1.removeNullFromUnion(t, true);
                             return [maybeNull !== null || p.isOptional, nonNulls];
                         }
                         else {
@@ -974,7 +1036,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                                 "get_optional<",
                                 cppType,
                                 ">(j, ",
-                                this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])]),
+                                this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(json)])]),
                                 ")"
                             ])
                         ]), ";");
@@ -985,7 +1047,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, p.isOptional);
                 this.emitLine(assignment.wrap([], this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, [
                     "j.at(",
-                    this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])),
+                    this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([Strings_1.stringEscape(json)])),
                     ").get<",
                     cppType,
                     ">()"
@@ -999,7 +1061,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 const t = p.type;
                 cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, false, p.isOptional);
                 toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, p.isOptional);
-                const [getterName, ,] = (0, Support_1.defined)(this._gettersAndSettersForPropertyName.get(name));
+                const [getterName, ,] = Support_1.defined(this._gettersAndSettersForPropertyName.get(name));
                 let getter;
                 if (this._options.codeFormat) {
                     getter = [getterName, "()"];
@@ -1009,7 +1071,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 }
                 let assignment = [
                     "j[",
-                    this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])),
+                    this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([Strings_1.stringEscape(json)])),
                     "] = ",
                     this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, ["x.", getter]),
                     ";"
@@ -1031,13 +1093,13 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     emitEnum(e, enumName) {
         const caseNames = [];
-        const enumValues = (0, EnumValues_1.enumCaseValues)(e, this.targetLanguage.name);
+        const enumValues = EnumValues_1.enumCaseValues(e, this.targetLanguage.name);
         this.forEachEnumCase(e, "none", (name, jsonName) => {
             if (caseNames.length > 0)
                 caseNames.push(", ");
             caseNames.push(name);
             if (enumValues !== undefined) {
-                const [enumValue] = (0, AccessorNames_1.getAccessorName)(enumValues, jsonName);
+                const [enumValue] = AccessorNames_1.getAccessorName(enumValues, jsonName);
                 if (enumValue !== undefined) {
                     caseNames.push(" = ", enumValue.toString());
                 }
@@ -1050,7 +1112,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("using ", unionName, " = ", this.variantType(u, false), ";");
     }
     emitUnionHeaders(u) {
-        const nonNulls = (0, TypeUtils_1.removeNullFromUnion)(u, true)[1];
+        const nonNulls = TypeUtils_1.removeNullFromUnion(u, true)[1];
         const variantType = this.cppTypeInOptional(nonNulls, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false);
         this.emitLine("void from_json(", this.withConst("json"), " & j, ", variantType, " & x);");
         this.emitLine("void to_json(json & j, ", this.withConst(variantType), " & x);");
@@ -1067,12 +1129,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             ["array", "is_array"],
             ["enum", "is_string"]
         ];
-        const nonNulls = (0, TypeUtils_1.removeNullFromUnion)(u, true)[1];
+        const nonNulls = TypeUtils_1.removeNullFromUnion(u, true)[1];
         const variantType = this.cppTypeInOptional(nonNulls, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false);
         this.emitBlock(["inline void from_json(", this.withConst("json"), " & j, ", variantType, " & x)"], false, () => {
             let onFirst = true;
             for (const [kind, func] of functionForKind) {
-                const typeForKind = (0, collection_utils_1.iterableFind)(nonNulls, t => t.kind === kind);
+                const typeForKind = collection_utils_1.iterableFind(nonNulls, t => t.kind === kind);
                 if (typeForKind === undefined)
                     continue;
                 this.emitLine(onFirst ? "if" : "else if", " (j.", func, "())");
@@ -1142,7 +1204,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     "> enumValues"
                 ], true, () => {
                     this.forEachEnumCase(e, "none", (name, jsonName) => {
-                        this.emitLine("{", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(jsonName)])]), ", ", ourQualifier, enumName, "::", name, "},");
+                        this.emitLine("{", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(jsonName)])]), ", ", ourQualifier, enumName, "::", name, "},");
                     });
                 });
                 this.emitLine(`auto iter = enumValues.find(j.get<${this._stringType.getType()}>());`);
@@ -1154,7 +1216,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 let onFirst = true;
                 this.forEachEnumCase(e, "none", (name, jsonName) => {
                     const maybeElse = onFirst ? "" : "else ";
-                    this.emitLine(maybeElse, "if (j == ", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(jsonName)])]), ") x = ", ourQualifier, enumName, "::", name, ";");
+                    this.emitLine(maybeElse, "if (j == ", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(jsonName)])]), ") x = ", ourQualifier, enumName, "::", name, ";");
                     onFirst = false;
                 });
                 this.emitLine('else throw "Input JSON does not conform to schema";');
@@ -1164,7 +1226,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitBlock(["inline void to_json(json & j, ", this.withConst([ourQualifier, enumName]), " & x)"], false, () => {
             this.emitBlock("switch (x)", false, () => {
                 this.forEachEnumCase(e, "none", (name, jsonName) => {
-                    this.emitLine("case ", ourQualifier, enumName, "::", name, ": j = ", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(jsonName)])]), "; break;");
+                    this.emitLine("case ", ourQualifier, enumName, "::", name, ": j = ", this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(jsonName)])]), "; break;");
                 });
                 this.emitLine('default: throw "This should not happen";');
             });
@@ -1174,10 +1236,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("using ", name, " = ", this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, true, false, false), ";");
     }
     emitAllUnionFunctions() {
-        this.forEachUniqueUnion("interposing", u => this.sourcelikeToString(this.cppTypeInOptional((0, TypeUtils_1.removeNullFromUnion)(u, true)[1], { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false)), (u) => this.emitUnionFunctions(u));
+        this.forEachUniqueUnion("interposing", u => this.sourcelikeToString(this.cppTypeInOptional(TypeUtils_1.removeNullFromUnion(u, true)[1], { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false)), (u) => this.emitUnionFunctions(u));
     }
     emitAllUnionHeaders() {
-        this.forEachUniqueUnion("interposing", u => this.sourcelikeToString(this.cppTypeInOptional((0, TypeUtils_1.removeNullFromUnion)(u, true)[1], { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false)), (u) => this.emitUnionHeaders(u));
+        this.forEachUniqueUnion("interposing", u => this.sourcelikeToString(this.cppTypeInOptional(TypeUtils_1.removeNullFromUnion(u, true)[1], { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false)), (u) => this.emitUnionHeaders(u));
     }
     emitOptionalHelpers() {
         this.emitLine("#ifndef NLOHMANN_OPT_HELPER");
@@ -1218,11 +1280,11 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 this.emitUnionTypedefs(t, name);
             }
             else {
-                return (0, Support_1.panic)(`Cannot declare type ${t.kind}`);
+                return Support_1.panic(`Cannot declare type ${t.kind}`);
             }
         }
         else {
-            return (0, Support_1.assertNever)(decl.kind);
+            return Support_1.assertNever(decl.kind);
         }
     }
     emitGetterSetter(t, getterName, setterName, memberName) {
@@ -1256,12 +1318,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 const member = this.lookupMemberName(name);
                 return [member, "(", member, ")"];
             });
-            this.emitLine(") : ", (0, collection_utils_1.arrayIntercalate)([", "], args), " {}");
+            this.emitLine(") : ", collection_utils_1.arrayIntercalate([", "], args), " {}");
             this.emitLine(classConstraint, "() = default;");
             this.emitLine("virtual ~", classConstraint, "() = default;");
             for (const member of constraintMembers) {
                 this.ensureBlankLine();
-                this.emitGetterSetter((0, collection_utils_1.withDefault)(member.cppConstType, member.cppType), this.lookupMemberName(member.getter), this.lookupMemberName(member.setter), this.lookupMemberName(member.name));
+                this.emitGetterSetter(collection_utils_1.withDefault(member.cppConstType, member.cppType), this.lookupMemberName(member.getter), this.lookupMemberName(member.setter), this.lookupMemberName(member.name));
             }
         });
         this.ensureBlankLine();
@@ -1354,7 +1416,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     emitHelperFunctions() {
         this._stringType.emitHelperFunctions();
         if (this._options.codeFormat &&
-            (0, collection_utils_1.iterableSome)(this.typeGraph.allTypesUnordered(), t => constraintsForType(t) !== undefined)) {
+            collection_utils_1.iterableSome(this.typeGraph.allTypesUnordered(), t => constraintsForType(t) !== undefined)) {
             this.emitConstraintClasses();
             this.ensureBlankLine();
         }
@@ -1534,7 +1596,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             else if (t.type instanceof Type_1.UnionType) {
                 propRecord.typeKind = "union";
                 /** Recurse into the union */
-                const [maybeNull] = (0, TypeUtils_1.removeNullFromUnion)(t.type, true);
+                const [maybeNull] = TypeUtils_1.removeNullFromUnion(t.type, true);
                 if (maybeNull !== undefined) {
                     /** Houston this is a variant, include it */
                     propRecord.kind = IncludeKind.Include;
@@ -1618,7 +1680,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                             this.emitLine("enum class ", name, " : ", this._enumType, ";");
                         }
                         else {
-                            (0, Support_1.panic)(`Invalid type "${rec.typeKind}" to forward declare`);
+                            Support_1.panic(`Invalid type "${rec.typeKind}" to forward declare`);
                         }
                     });
                 });
@@ -1689,8 +1751,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         /** Gather all the unique/custom types used by the schema */
         this._allTypeNames.clear();
         this.forEachDeclaration("none", decl => {
-            const definedTypes = (0, TypeUtils_1.directlyReachableTypes)(decl.type, t => {
-                if ((0, TypeUtils_1.isNamedType)(t) && (t instanceof Type_1.ClassType || t instanceof Type_1.EnumType || t instanceof Type_1.UnionType)) {
+            const definedTypes = TypeUtils_1.directlyReachableTypes(decl.type, t => {
+                if (TypeUtils_1.isNamedType(t) && (t instanceof Type_1.ClassType || t instanceof Type_1.EnumType || t instanceof Type_1.UnionType)) {
                     return new Set([
                         this.sourcelikeToString(this.cppType(t, {
                             needsForwardIndirection: false,
@@ -1701,7 +1763,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 }
                 return null;
             });
-            this._allTypeNames = (0, collection_utils_1.setUnion)(definedTypes, this._allTypeNames);
+            this._allTypeNames = collection_utils_1.setUnion(definedTypes, this._allTypeNames);
         });
         if (this._options.typeSourceStyle) {
             this.emitSingleSourceStructure(proposedFilename);
@@ -1715,101 +1777,5 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         let newType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: true }, false, true, false);
         return originalType !== newType;
     }
-    NarrowString = new (class extends BaseString {
-        constructor() {
-            super("std::string", "const std::string & ", "std::smatch", "std::regex", "", new WrappingCode(["std::to_string("], [")"]), "", "");
-        }
-        wrapEncodingChange(_qualifier, _fromType, _toType, inner) {
-            return inner;
-        }
-        emitHelperFunctions() {
-            return;
-        }
-    })();
-    WideString = new (class extends BaseString {
-        superThis;
-        constructor(superThis) {
-            super("std::wstring", "const std::wstring & ", "std::wsmatch", "std::wregex", "L", new WrappingCode(["std::to_wstring("], [")"]), "Utf16_Utf8", "convert");
-            this.superThis = superThis;
-        }
-        wrapEncodingChange(qualifier, fromType, toType, inner) {
-            if (this.superThis.sourcelikeToString(fromType) === this.superThis.sourcelikeToString(toType)) {
-                return inner;
-            }
-            return [
-                addQualifier(qualifier, [this._encodingClass]),
-                "<",
-                fromType,
-                ", ",
-                toType,
-                ">::",
-                this._encodingFunction,
-                "(",
-                inner,
-                ")"
-            ];
-        }
-        emitHelperFunctions() {
-            this.superThis.emitLine("template<typename T>");
-            this.superThis.emitLine("struct tag {};");
-            this.superThis.ensureBlankLine();
-            this.superThis.emitLine("template<typename fromType, typename toType>");
-            this.superThis.emitBlock(["class Utf16_Utf8"], true, () => {
-                this.superThis.emitLine("private:");
-                this.superThis.emitLine("template<typename TF, typename TT>");
-                this.superThis.emitBlock(["static toType convert(tag<std::shared_ptr<TF> >, tag<std::shared_ptr<TT> >, fromType ptr)"], false, () => {
-                    this.superThis.emitLine("if (ptr == nullptr) return std::unique_ptr<TT>(); else return std::unique_ptr<TT>(new TT(Utf16_Utf8<TF,TT>::convert(*ptr)));");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitLine("template<typename TF, typename TT>");
-                this.superThis.emitBlock(["static toType convert(tag<std::vector<TF> >, tag<std::vector<TT> >, fromType v)"], false, () => {
-                    this.superThis.emitLine("auto it = v.begin();");
-                    this.superThis.emitLine("auto newVector = std::vector<TT>();");
-                    this.superThis.emitBlock(["while (it != v.end())"], false, () => {
-                        this.superThis.emitLine("newVector.push_back(Utf16_Utf8<TF,TT>::convert(*it));");
-                        this.superThis.emitLine("it++;");
-                    });
-                    this.superThis.emitLine("return newVector;");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitLine("template<typename KF, typename VF, typename KT, typename VT>");
-                this.superThis.emitBlock(["static toType convert(tag<std::map<KF,VF> >, tag<std::map<KT,VT> >, fromType m)"], false, () => {
-                    this.superThis.emitLine("auto it = m.begin();");
-                    this.superThis.emitLine("auto newMap = std::map<KT, VT>();");
-                    this.superThis.emitBlock(["while (it != m.end())"], false, () => {
-                        this.superThis.emitLine("newMap.insert(std::pair<KT, VT>(Utf16_Utf8<KF, KT>::convert(it->first), Utf16_Utf8<VF, VT>::convert(it->second)));");
-                        this.superThis.emitLine("it++;");
-                    });
-                    this.superThis.emitLine("return newMap;");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitLine("template<typename TF, typename TT>");
-                this.superThis.emitBlock(["static fromType convert(tag<TF>, tag<TT>, fromType from)"], false, () => {
-                    this.superThis.emitLine("return from;");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitBlock(["static std::wstring convert(tag<std::string>, tag<std::wstring>, std::string str)"], false, () => {
-                    this.superThis.emitLine("return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t, 0x10ffff, std::little_endian>, wchar_t>{}.from_bytes(str.data());");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitBlock(["static std::string convert(tag<std::wstring>, tag<std::string>, std::wstring str)"], false, () => {
-                    this.superThis.emitLine("return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t, 0x10ffff, std::little_endian>, wchar_t>{}.to_bytes(str.data());");
-                });
-                this.superThis.ensureBlankLine();
-                this.superThis.emitLine("public:");
-                this.superThis.emitBlock(["static toType convert(fromType in)"], false, () => {
-                    this.superThis.emitLine("return convert(tag<fromType>(), tag<toType>(), in);");
-                });
-            });
-            this.superThis.ensureBlankLine();
-            this.superThis.emitLine("template<typename T>");
-            this.superThis.emitBlock(["std::wstring wdump(const T& j)"], false, () => {
-                this.superThis.emitLine("std::ostringstream s;");
-                this.superThis.emitLine("s << j;");
-                this.superThis.emitLine("return ", this.superThis.ourQualifier(false), "Utf16_Utf8<std::string, std::wstring>::convert(s.str()); ");
-            });
-            this.superThis.ensureBlankLine();
-        }
-    })(this);
 }
 exports.CPlusPlusRenderer = CPlusPlusRenderer;