quicktype 17.0.6 → 18.0.1

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

@@ -1,5 +1,6 @@
 "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");
@@ -100,19 +101,19 @@ class CPlusPlusTargetLanguage extends TargetLanguage_1.TargetLanguage {
         return true;
     }
     makeRenderer(renderContext, untypedOptionValues) {
-        return new CPlusPlusRenderer(this, renderContext, RendererOptions_1.getOptionValues(exports.cPlusPlusOptions, untypedOptionValues));
+        return new CPlusPlusRenderer(this, renderContext, (0, RendererOptions_1.getOptionValues)(exports.cPlusPlusOptions, untypedOptionValues));
     }
 }
 exports.CPlusPlusTargetLanguage = CPlusPlusTargetLanguage;
 function constraintsForType(t) {
-    const minMax = Constraints_1.minMaxValueForType(t);
-    const minMaxLength = Constraints_1.minMaxLengthForType(t);
-    const pattern = Constraints_1.patternForType(t);
+    const minMax = (0, Constraints_1.minMaxValueForType)(t);
+    const minMaxLength = (0, Constraints_1.minMaxLengthForType)(t);
+    const pattern = (0, Constraints_1.patternForType)(t);
     if (minMax === undefined && minMaxLength === undefined && pattern === undefined)
         return undefined;
     return { minMax, minMaxLength, pattern };
 }
-const legalizeName = Strings_1.legalizeCharacters(cp => Strings_1.isAscii(cp) && Strings_1.isLetterOrUnderscoreOrDigit(cp));
+const legalizeName = (0, Strings_1.legalizeCharacters)(cp => (0, Strings_1.isAscii)(cp) && (0, Strings_1.isLetterOrUnderscoreOrDigit)(cp));
 const keywords = [
     "alignas",
     "alignof",
@@ -274,6 +275,8 @@ function addQualifier(qualifier, qualified) {
     return [qualifier, qualified];
 }
 class WrappingCode {
+    _start;
+    _end;
     constructor(start, end) {
         this._start = start;
         this._end = end;
@@ -283,6 +286,14 @@ 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),
@@ -313,112 +324,39 @@ 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 = Strings_1.makeNameStyle(this.typeNamingStyle, legalizeName);
+        this._namedTypeNameStyle = (0, Strings_1.makeNameStyle)(this.typeNamingStyle, legalizeName);
         this.enumeratorNamingStyle = _options.enumeratorNamingStyle;
-        this._memberNameStyle = Strings_1.makeNameStyle(_options.memberNamingStyle, legalizeName);
-        this._memberNamingFunction = Naming_1.funPrefixNamer("members", this._memberNameStyle);
+        this._memberNameStyle = (0, Strings_1.makeNameStyle)(_options.memberNamingStyle, legalizeName);
+        this._memberNamingFunction = (0, Naming_1.funPrefixNamer)("members", this._memberNameStyle);
         this._gettersAndSettersForPropertyName = new Map();
         this._allTypeNames = new Set();
         this._generatedFiles = new Set();
@@ -481,10 +419,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         ];
     }
     lookupGlobalName(type) {
-        return Support_1.defined(this._generatedGlobalNames.get(type));
+        return (0, Support_1.defined)(this._generatedGlobalNames.get(type));
     }
     lookupMemberName(type) {
-        return Support_1.defined(this._generatedMemberNames.get(type));
+        return (0, Support_1.defined)(this._generatedMemberNames.get(type));
     }
     addGlobalName(type) {
         const genName = this._namedTypeNameStyle(GlobalNames[type]);
@@ -495,10 +433,10 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this._generatedMemberNames.set(type, this._memberNameStyle(MemberNames[type]));
     }
     setupGlobalNames() {
-        for (const v of Support_1.numberEnumValues(GlobalNames)) {
+        for (const v of (0, Support_1.numberEnumValues)(GlobalNames)) {
             this.addGlobalName(v);
         }
-        for (const v of Support_1.numberEnumValues(MemberNames)) {
+        for (const v of (0, Support_1.numberEnumValues)(MemberNames)) {
             this.addMemberName(v);
         }
     }
@@ -512,7 +450,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return { names: [], includeGlobalForbidden: true };
     }
     makeNamedTypeNamer() {
-        return Naming_1.funPrefixNamer("types", this._namedTypeNameStyle);
+        return (0, Naming_1.funPrefixNamer)("types", this._namedTypeNameStyle);
     }
     namerForObjectProperty() {
         return this._memberNamingFunction;
@@ -521,7 +459,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return null;
     }
     makeEnumCaseNamer() {
-        return Naming_1.funPrefixNamer("enumerators", Strings_1.makeNameStyle(this.enumeratorNamingStyle, legalizeName));
+        return (0, Naming_1.funPrefixNamer)("enumerators", (0, 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)}`);
@@ -546,7 +484,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("#include ", global ? "<" : '"', name, global ? ">" : '"');
     }
     startFile(basename, includeHelper = true) {
-        Support_2.assert(this._currentFilename === undefined, "Previous file wasn't finished");
+        (0, Support_2.assert)(this._currentFilename === undefined, "Previous file wasn't finished");
         if (basename !== undefined) {
             this._currentFilename = this.sourcelikeToString(basename);
         }
@@ -606,7 +544,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.ensureBlankLine();
     }
     finishFile() {
-        super.finishFile(Support_1.defined(this._currentFilename));
+        super.finishFile((0, Support_1.defined)(this._currentFilename));
         this._currentFilename = undefined;
     }
     get needsTypeDeclarationBeforeUse() {
@@ -637,7 +575,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
     }
     emitNamespaces(namespaceNames, f) {
-        const namesArray = collection_utils_1.toReadonlyArray(namespaceNames);
+        const namesArray = (0, collection_utils_1.toReadonlyArray)(namespaceNames);
         const first = namesArray[0];
         if (first === undefined) {
             f();
@@ -648,7 +586,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     cppTypeInOptional(nonNulls, ctx, withIssues, forceNarrowString) {
         if (nonNulls.size === 1) {
-            return this.cppType(Support_1.defined(collection_utils_1.iterableFirst(nonNulls)), ctx, withIssues, forceNarrowString, false);
+            return this.cppType((0, Support_1.defined)((0, collection_utils_1.iterableFirst)(nonNulls)), ctx, withIssues, forceNarrowString, false);
         }
         const typeList = [];
         for (const t of nonNulls) {
@@ -664,8 +602,8 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return [this._variantType, "<", typeList, ">"];
     }
     variantType(u, inJsonNamespace) {
-        const [maybeNull, nonNulls] = TypeUtils_1.removeNullFromUnion(u, true);
-        Support_2.assert(nonNulls.size >= 2, "Variant not needed for less than two types.");
+        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 indirection = maybeNull !== null;
         const variant = this.cppTypeInOptional(nonNulls, { needsForwardIndirection: !indirection, needsOptionalIndirection: !indirection, inJsonNamespace }, true, false);
         if (!indirection) {
@@ -674,7 +612,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         return [optionalType, "<", variant, ">"];
     }
     ourQualifier(inJsonNamespace) {
-        return inJsonNamespace ? [collection_utils_1.arrayIntercalate("::", this._namespaceNames), "::"] : [];
+        return inJsonNamespace ? [(0, collection_utils_1.arrayIntercalate)("::", this._namespaceNames), "::"] : [];
     }
     jsonQualifier(inJsonNamespace) {
         return inJsonNamespace ? [] : "nlohmann::";
@@ -695,12 +633,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 }
             }
         }
-        let typeSource = TypeUtils_1.matchType(t, _anyType => {
+        let typeSource = (0, TypeUtils_1.matchType)(t, _anyType => {
             isOptional = false;
-            return Source_1.maybeAnnotated(withIssues, Annotation_1.anyTypeIssueAnnotation, [this.jsonQualifier(inJsonNamespace), "json"]);
+            return (0, 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 (0, 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 +663,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 ">"
             ];
         }, enumType => [this.ourQualifier(inJsonNamespace), this.nameForNamedType(enumType)], unionType => {
-            const nullable = TypeUtils_1.nullableFromUnion(unionType);
+            const nullable = (0, TypeUtils_1.nullableFromUnion)(unionType);
             if (nullable === null)
                 return [this.ourQualifier(inJsonNamespace), this.nameForNamedType(unionType)];
             isOptional = true;
@@ -792,7 +730,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     });
                     /** intentional "fall-through", add all subtypes as well - but forced include */
                 }
-                const [hasNull, nonNulls] = TypeUtils_1.removeNullFromUnion(t);
+                const [hasNull, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(t);
                 isVariant = hasNull !== null;
                 /** we need to collect all the subtypes of the union */
                 for (const tt of nonNulls) {
@@ -829,7 +767,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] = Support_1.defined(this._gettersAndSettersForPropertyName.get(name));
+                const [getterName, mutableGetterName, setterName] = (0, 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
@@ -888,7 +826,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                     : [
                         this._stringType.getType(),
                         "(",
-                        this._stringType.createStringLiteral([Strings_1.stringEscape(pattern)]),
+                        this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(pattern)]),
                         ")"
                     ],
                 ")"
@@ -979,7 +917,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] = Support_1.defined(this._gettersAndSettersForPropertyName.get(name));
+                const [, , setterName] = (0, Support_1.defined)(this._gettersAndSettersForPropertyName.get(name));
                 const t = p.type;
                 let assignment;
                 if (this._options.codeFormat) {
@@ -992,7 +930,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([Strings_1.stringEscape(json)])]),
+                        this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])]),
                         ")"
                     ]), ";");
                     return;
@@ -1000,7 +938,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] = TypeUtils_1.removeNullFromUnion(t, true);
+                            const [maybeNull, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(t, true);
                             return [maybeNull !== null || p.isOptional, nonNulls];
                         }
                         else {
@@ -1026,7 +964,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                                 "get_optional<",
                                 cppType,
                                 ">(j, ",
-                                this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([Strings_1.stringEscape(json)])]),
+                                this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), [this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])]),
                                 ")"
                             ])
                         ]), ";");
@@ -1037,7 +975,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, 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([Strings_1.stringEscape(json)])),
+                    this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])),
                     ").get<",
                     cppType,
                     ">()"
@@ -1051,7 +989,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 const t = p.type;
                 cppType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, false, false, p.isOptional);
                 toType = this.cppType(t, { needsForwardIndirection: true, needsOptionalIndirection: true, inJsonNamespace: false }, false, true, p.isOptional);
-                const [getterName, ,] = Support_1.defined(this._gettersAndSettersForPropertyName.get(name));
+                const [getterName, ,] = (0, Support_1.defined)(this._gettersAndSettersForPropertyName.get(name));
                 let getter;
                 if (this._options.codeFormat) {
                     getter = [getterName, "()"];
@@ -1061,7 +999,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 }
                 let assignment = [
                     "j[",
-                    this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([Strings_1.stringEscape(json)])),
+                    this._stringType.wrapEncodingChange([ourQualifier], this._stringType.getType(), this.NarrowString.getType(), this._stringType.createStringLiteral([(0, Strings_1.stringEscape)(json)])),
                     "] = ",
                     this._stringType.wrapEncodingChange([ourQualifier], cppType, toType, ["x.", getter]),
                     ";"
@@ -1083,13 +1021,13 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     emitEnum(e, enumName) {
         const caseNames = [];
-        const enumValues = EnumValues_1.enumCaseValues(e, this.targetLanguage.name);
+        const enumValues = (0, 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] = AccessorNames_1.getAccessorName(enumValues, jsonName);
+                const [enumValue] = (0, AccessorNames_1.getAccessorName)(enumValues, jsonName);
                 if (enumValue !== undefined) {
                     caseNames.push(" = ", enumValue.toString());
                 }
@@ -1107,7 +1045,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         // variant type. If at least one of the Ts is our type then we could get away with regular adl definitions,
         // but it's nontrivial to detect that (consider variant<string, variant<map<string, string>, int>> which
         // does need an adl_serializer specialization) so we'll just specialize every time.
-        const nonNulls = TypeUtils_1.removeNullFromUnion(u, true)[1];
+        const nonNulls = (0, TypeUtils_1.removeNullFromUnion)(u, true)[1];
         const variantType = this.cppTypeInOptional(nonNulls, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false);
         this.emitLine("template <>");
         this.emitBlock(["struct adl_serializer<", variantType, ">"], true, () => {
@@ -1128,12 +1066,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             ["array", "is_array"],
             ["enum", "is_string"]
         ];
-        const nonNulls = TypeUtils_1.removeNullFromUnion(u, true)[1];
+        const nonNulls = (0, TypeUtils_1.removeNullFromUnion)(u, true)[1];
         const variantType = this.cppTypeInOptional(nonNulls, { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false);
         this.emitBlock(["inline void adl_serializer<", variantType, ">::from_json(", this.withConst("json"), " & j, ", variantType, " & x)"], false, () => {
             let onFirst = true;
             for (const [kind, func] of functionForKind) {
-                const typeForKind = collection_utils_1.iterableFind(nonNulls, t => t.kind === kind);
+                const typeForKind = (0, collection_utils_1.iterableFind)(nonNulls, t => t.kind === kind);
                 if (typeForKind === undefined)
                     continue;
                 this.emitLine(onFirst ? "if" : "else if", " (j.", func, "())");
@@ -1203,7 +1141,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([Strings_1.stringEscape(jsonName)])]), ", ", ourQualifier, enumName, "::", name, "},");
+                        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(`auto iter = enumValues.find(j.get<${this._stringType.getType()}>());`);
@@ -1215,7 +1153,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([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([(0, Strings_1.stringEscape)(jsonName)])]), ") x = ", ourQualifier, enumName, "::", name, ";");
                     onFirst = false;
                 });
                 this.emitLine('else throw "Input JSON does not conform to schema";');
@@ -1225,7 +1163,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([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([(0, Strings_1.stringEscape)(jsonName)])]), "; break;");
                 });
                 this.emitLine('default: throw "This should not happen";');
             });
@@ -1235,10 +1173,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("leading-and-interposing", u => this.sourcelikeToString(this.cppTypeInOptional(TypeUtils_1.removeNullFromUnion(u, true)[1], { needsForwardIndirection: false, needsOptionalIndirection: false, inJsonNamespace: true }, false, false)), (u) => this.emitUnionFunctions(u));
+        this.forEachUniqueUnion("leading-and-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));
     }
     emitAllUnionHeaders() {
-        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));
+        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));
     }
     emitOptionalHelpers() {
         this.emitLine("#ifndef NLOHMANN_OPT_HELPER");
@@ -1279,11 +1217,11 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 this.emitUnionTypedefs(t, name);
             }
             else {
-                return Support_1.panic(`Cannot declare type ${t.kind}`);
+                return (0, Support_1.panic)(`Cannot declare type ${t.kind}`);
             }
         }
         else {
-            return Support_1.assertNever(decl.kind);
+            return (0, Support_1.assertNever)(decl.kind);
         }
     }
     emitGetterSetter(t, getterName, setterName, memberName) {
@@ -1317,12 +1255,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 const member = this.lookupMemberName(name);
                 return [member, "(", member, ")"];
             });
-            this.emitLine(") : ", collection_utils_1.arrayIntercalate([", "], args), " {}");
+            this.emitLine(") : ", (0, collection_utils_1.arrayIntercalate)([", "], args), " {}");
             this.emitLine(classConstraint, "() = default;");
             this.emitLine("virtual ~", classConstraint, "() = default;");
             for (const member of constraintMembers) {
                 this.ensureBlankLine();
-                this.emitGetterSetter(collection_utils_1.withDefault(member.cppConstType, member.cppType), this.lookupMemberName(member.getter), this.lookupMemberName(member.setter), this.lookupMemberName(member.name));
+                this.emitGetterSetter((0, collection_utils_1.withDefault)(member.cppConstType, member.cppType), this.lookupMemberName(member.getter), this.lookupMemberName(member.setter), this.lookupMemberName(member.name));
             }
         });
         this.ensureBlankLine();
@@ -1415,7 +1353,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     emitHelperFunctions() {
         this._stringType.emitHelperFunctions();
         if (this._options.codeFormat &&
-            collection_utils_1.iterableSome(this.typeGraph.allTypesUnordered(), t => constraintsForType(t) !== undefined)) {
+            (0, collection_utils_1.iterableSome)(this.typeGraph.allTypesUnordered(), t => constraintsForType(t) !== undefined)) {
             this.emitConstraintClasses();
             this.ensureBlankLine();
         }
@@ -1628,7 +1566,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             else if (t.type instanceof Type_1.UnionType) {
                 propRecord.typeKind = "union";
                 /** Recurse into the union */
-                const [maybeNull] = TypeUtils_1.removeNullFromUnion(t.type, true);
+                const [maybeNull] = (0, TypeUtils_1.removeNullFromUnion)(t.type, true);
                 if (maybeNull !== undefined) {
                     /** Houston this is a variant, include it */
                     propRecord.kind = IncludeKind.Include;
@@ -1712,7 +1650,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                             this.emitLine("enum class ", name, " : ", this._enumType, ";");
                         }
                         else {
-                            Support_1.panic(`Invalid type "${rec.typeKind}" to forward declare`);
+                            (0, Support_1.panic)(`Invalid type "${rec.typeKind}" to forward declare`);
                         }
                     });
                 });
@@ -1783,8 +1721,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 = 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)) {
+            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)) {
                     return new Set([
                         this.sourcelikeToString(this.cppType(t, {
                             needsForwardIndirection: false,
@@ -1795,7 +1733,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 }
                 return null;
             });
-            this._allTypeNames = collection_utils_1.setUnion(definedTypes, this._allTypeNames);
+            this._allTypeNames = (0, collection_utils_1.setUnion)(definedTypes, this._allTypeNames);
         });
         if (this._options.typeSourceStyle) {
             this.emitSingleSourceStructure(proposedFilename);
@@ -1809,5 +1747,101 @@ 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;