The OpenD Programming Language

1 // Written in the D programming language.
2 
3 /**
4 Implements functionality to read and write JavaScript Object Notation values.
5 
6 JavaScript Object Notation is a lightweight data interchange format commonly used in web services and configuration files.
7 It's easy for humans to read and write, and it's easy for machines to parse and generate.
8 
9 $(RED Warning: While $(LREF JSONValue) is fine for small-scale use, at the range of hundreds of megabytes it is
10 known to cause and exacerbate GC problems. If you encounter problems, try replacing it with a stream parser. See
11 also $(LINK https://forum.dlang.org/post/dzfyaxypmkdrpakmycjv@forum.dlang.org).)
12 
13 Copyright: Copyright Jeremie Pelletier 2008 - 2009.
14 License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
15 Authors:   Jeremie Pelletier, David Herberth
16 References: $(LINK http://json.org/), $(LINK http://seriot.ch/parsing_json.html)
17 Source:    $(PHOBOSSRC std/json.d)
18 */
19 /*
20          Copyright Jeremie Pelletier 2008 - 2009.
21 Distributed under the Boost Software License, Version 1.0.
22    (See accompanying file LICENSE_1_0.txt or copy at
23          http://www.boost.org/LICENSE_1_0.txt)
24 */
25 module std.json;
26 
27 import std.array;
28 import std.conv;
29 import std.range;
30 import std.traits;
31 
32 ///
33 @system unittest
34 {
35     import std.conv : to;
36 
37     // parse a file or string of json into a usable structure
38     string s = `{ "language": "D", "rating": 3.5, "code": "42" }`;
39     JSONValue j = parseJSON(s);
40     // j and j["language"] return JSONValue,
41     // j["language"].str returns a string
42     assert(j["language"].str == "D");
43     assert(j["rating"].floating == 3.5);
44 
45     // check a type
46     long x;
47     if (const(JSONValue)* code = "code" in j)
48     {
49         if (code.type() == JSONType.integer)
50             x = code.integer;
51         else
52             x = to!int(code.str);
53     }
54 
55     // create a json struct
56     JSONValue jj = [ "language": "D" ];
57     // rating doesnt exist yet, so use .object to assign
58     jj.object["rating"] = JSONValue(3.5);
59     // create an array to assign to list
60     jj.object["list"] = JSONValue( ["a", "b", "c"] );
61     // list already exists, so .object optional
62     jj["list"].array ~= JSONValue("D");
63 
64     string jjStr = `{"language":"D","list":["a","b","c","D"],"rating":3.5}`;
65     assert(jj.toString == jjStr);
66 }
67 
68 /**
69 String literals used to represent special float values within JSON strings.
70 */
71 enum JSONFloatLiteral : string
72 {
73     nan         = "NaN",       /// String representation of floating-point NaN
74     inf         = "Infinite",  /// String representation of floating-point Infinity
75     negativeInf = "-Infinite", /// String representation of floating-point negative Infinity
76 }
77 
78 /**
79 Flags that control how JSON is encoded and parsed.
80 */
81 enum JSONOptions
82 {
83     none,                       /// Standard parsing and encoding
84     specialFloatLiterals = 0x1, /// Encode NaN and Inf float values as strings
85     escapeNonAsciiChars = 0x2,  /// Encode non-ASCII characters with a Unicode escape sequence
86     doNotEscapeSlashes = 0x4,   /// Do not escape slashes ('/')
87     strictParsing = 0x8,        /// Strictly follow RFC-8259 grammar when parsing
88 }
89 
90 /**
91 Enumeration of JSON types
92 */
93 enum JSONType : byte
94 {
95     /// Indicates the type of a `JSONValue`.
96     null_,
97     string,   /// ditto
98     integer,  /// ditto
99     uinteger, /// ditto
100     float_,   /// ditto
101     array,    /// ditto
102     object,   /// ditto
103     true_,    /// ditto
104     false_,   /// ditto
105     // FIXME: Find some way to deprecate the enum members below, which does NOT
106     // create lots of spam-like deprecation warnings, which can't be fixed
107     // by the user. See discussion on this issue at
108     // https://forum.dlang.org/post/feudrhtxkaxxscwhhhff@forum.dlang.org
109     /* deprecated("Use .null_")    */ NULL = null_,
110     /* deprecated("Use .string")   */ STRING = string,
111     /* deprecated("Use .integer")  */ INTEGER = integer,
112     /* deprecated("Use .uinteger") */ UINTEGER = uinteger,
113     /* deprecated("Use .float_")   */ FLOAT = float_,
114     /* deprecated("Use .array")    */ ARRAY = array,
115     /* deprecated("Use .object")   */ OBJECT = object,
116     /* deprecated("Use .true_")    */ TRUE = true_,
117     /* deprecated("Use .false_")   */ FALSE = false_,
118 }
119 
120 deprecated("Use JSONType and the new enum member names") alias JSON_TYPE = JSONType;
121 
122 /**
123 JSON value node
124 */
125 struct JSONValue
126 {
127     import std.exception : enforce;
128 
129     union Store
130     {
131         string                          str;
132         long                            integer;
133         ulong                           uinteger;
134         double                          floating;
135         JSONValue[string]               object;
136         JSONValue[]                     array;
137     }
138     private Store store;
139     private JSONType type_tag;
140 
141     /**
142       Returns the JSONType of the value stored in this structure.
143     */
144     @property JSONType type() const pure nothrow @safe @nogc
145     {
146         return type_tag;
147     }
148     ///
149     @safe unittest
150     {
151           string s = "{ \"language\": \"D\" }";
152           JSONValue j = parseJSON(s);
153           assert(j.type == JSONType.object);
154           assert(j["language"].type == JSONType..string);
155     }
156 
157     /***
158      * Value getter/setter for `JSONType.string`.
159      * Throws: `JSONException` for read access if `type` is not
160      * `JSONType.string`.
161      */
162     @property string str() const pure @trusted return scope
163     {
164         enforce!JSONException(type == JSONType..string,
165                                 "JSONValue is not a string");
166         return store.str;
167     }
168     /// ditto
169     @property string str(return scope string v) pure nothrow @nogc @trusted return // TODO make @safe
170     {
171         assign(v);
172         return v;
173     }
174     ///
175     @safe unittest
176     {
177         JSONValue j = [ "language": "D" ];
178 
179         // get value
180         assert(j["language"].str == "D");
181 
182         // change existing key to new string
183         j["language"].str = "Perl";
184         assert(j["language"].str == "Perl");
185     }
186 
187     /***
188      * Value getter/setter for `JSONType.integer`.
189      * Throws: `JSONException` for read access if `type` is not
190      * `JSONType.integer`.
191      */
192     @property long integer() const pure @safe
193     {
194         enforce!JSONException(type == JSONType.integer,
195                                 "JSONValue is not an integer");
196         return store.integer;
197     }
198     /// ditto
199     @property long integer(long v) pure nothrow @safe @nogc
200     {
201         assign(v);
202         return store.integer;
203     }
204 
205     /***
206      * Value getter/setter for `JSONType.uinteger`.
207      * Throws: `JSONException` for read access if `type` is not
208      * `JSONType.uinteger`.
209      */
210     @property ulong uinteger() const pure @safe
211     {
212         enforce!JSONException(type == JSONType.uinteger,
213                                 "JSONValue is not an unsigned integer");
214         return store.uinteger;
215     }
216     /// ditto
217     @property ulong uinteger(ulong v) pure nothrow @safe @nogc
218     {
219         assign(v);
220         return store.uinteger;
221     }
222 
223     /***
224      * Value getter/setter for `JSONType.float_`. Note that despite
225      * the name, this is a $(B 64)-bit `double`, not a 32-bit `float`.
226      * Throws: `JSONException` for read access if `type` is not
227      * `JSONType.float_`.
228      */
229     @property double floating() const pure @safe
230     {
231         enforce!JSONException(type == JSONType.float_,
232                                 "JSONValue is not a floating type");
233         return store.floating;
234     }
235     /// ditto
236     @property double floating(double v) pure nothrow @safe @nogc
237     {
238         assign(v);
239         return store.floating;
240     }
241 
242     /***
243      * Value getter/setter for boolean stored in JSON.
244      * Throws: `JSONException` for read access if `this.type` is not
245      * `JSONType.true_` or `JSONType.false_`.
246      */
247     @property bool boolean() const pure @safe
248     {
249         if (type == JSONType.true_) return true;
250         if (type == JSONType.false_) return false;
251 
252         throw new JSONException("JSONValue is not a boolean type");
253     }
254     /// ditto
255     @property bool boolean(bool v) pure nothrow @safe @nogc
256     {
257         assign(v);
258         return v;
259     }
260     ///
261     @safe unittest
262     {
263         JSONValue j = true;
264         assert(j.boolean == true);
265 
266         j.boolean = false;
267         assert(j.boolean == false);
268 
269         j.integer = 12;
270         import std.exception : assertThrown;
271         assertThrown!JSONException(j.boolean);
272     }
273 
274     /***
275      * Value getter/setter for `JSONType.object`.
276      * Throws: `JSONException` for read access if `type` is not
277      * `JSONType.object`.
278      * Note: This is @system because of the following pattern:
279        ---
280        auto a = &(json.object());
281        json.uinteger = 0;        // overwrite AA pointer
282        (*a)["hello"] = "world";  // segmentation fault
283        ---
284      */
285     @property ref inout(JSONValue[string]) object() inout pure @system return
286     {
287         enforce!JSONException(type == JSONType.object,
288                                 "JSONValue is not an object");
289         return store.object;
290     }
291     /// ditto
292     @property JSONValue[string] object(return scope JSONValue[string] v) pure nothrow @nogc @trusted // TODO make @safe
293     {
294         assign(v);
295         return v;
296     }
297 
298     /***
299      * Value getter for `JSONType.object`.
300      * Unlike `object`, this retrieves the object by value
301      * and can be used in @safe code.
302      *
303      * One possible caveat is that, if the returned value is null,
304      * modifications will not be visible:
305      * ---
306      * JSONValue json;
307      * json.object = null;
308      * json.objectNoRef["hello"] = JSONValue("world");
309      * assert("hello" !in json.object);
310      * ---
311      *
312      * Throws: `JSONException` for read access if `type` is not
313      * `JSONType.object`.
314      */
315     @property inout(JSONValue[string]) objectNoRef() inout pure @trusted
316     {
317         enforce!JSONException(type == JSONType.object,
318                                 "JSONValue is not an object");
319         return store.object;
320     }
321 
322     /***
323      * Value getter/setter for `JSONType.array`.
324      * Throws: `JSONException` for read access if `type` is not
325      * `JSONType.array`.
326      * Note: This is @system because of the following pattern:
327        ---
328        auto a = &(json.array());
329        json.uinteger = 0;  // overwrite array pointer
330        (*a)[0] = "world";  // segmentation fault
331        ---
332      */
333     @property ref inout(JSONValue[]) array() scope return inout pure @system
334     {
335         enforce!JSONException(type == JSONType.array,
336                                 "JSONValue is not an array");
337         return store.array;
338     }
339     /// ditto
340     @property JSONValue[] array(return scope JSONValue[] v) pure nothrow @nogc @trusted scope // TODO make @safe
341     {
342         assign(v);
343         return v;
344     }
345 
346     /***
347      * Value getter for `JSONType.array`.
348      * Unlike `array`, this retrieves the array by value and can be used in @safe code.
349      *
350      * One possible caveat is that, if you append to the returned array,
351      * the new values aren't visible in the `JSONValue`:
352      * ---
353      * JSONValue json;
354      * json.array = [JSONValue("hello")];
355      * json.arrayNoRef ~= JSONValue("world");
356      * assert(json.array.length == 1);
357      * ---
358      *
359      * Throws: `JSONException` for read access if `type` is not
360      * `JSONType.array`.
361      */
362     @property inout(JSONValue[]) arrayNoRef() inout pure @trusted
363     {
364         enforce!JSONException(type == JSONType.array,
365                                 "JSONValue is not an array");
366         return store.array;
367     }
368 
369     /// Test whether the type is `JSONType.null_`
370     @property bool isNull() const pure nothrow @safe @nogc
371     {
372         return type == JSONType.null_;
373     }
374 
375     /***
376      * A convenience getter that returns this `JSONValue` as the specified D type.
377      * Note: Only numeric types, `bool`, `string`, `JSONValue[string]`, and `JSONValue[]` types are accepted
378      * Throws: `JSONException` if `T` cannot hold the contents of this `JSONValue`
379      *         `ConvException` in case of integer overflow when converting to `T`
380      */
381     @property inout(T) get(T)() inout const pure @safe
382     {
383         static if (is(immutable T == immutable string))
384         {
385             return str;
386         }
387         else static if (is(immutable T == immutable bool))
388         {
389             return boolean;
390         }
391         else static if (isFloatingPoint!T)
392         {
393             switch (type)
394             {
395             case JSONType.float_:
396                 return cast(T) floating;
397             case JSONType.uinteger:
398                 return cast(T) uinteger;
399             case JSONType.integer:
400                 return cast(T) integer;
401             default:
402                 throw new JSONException("JSONValue is not a number type");
403             }
404         }
405         else static if (isIntegral!T)
406         {
407             switch (type)
408             {
409             case JSONType.uinteger:
410                 return uinteger.to!T;
411             case JSONType.integer:
412                 return integer.to!T;
413             default:
414                 throw new JSONException("JSONValue is not a an integral type");
415             }
416         }
417         else
418         {
419             static assert(false, "Unsupported type");
420         }
421     }
422     // This specialization is needed because arrayNoRef requires inout
423     @property inout(T) get(T : JSONValue[])() inout pure @trusted /// ditto
424     {
425         return arrayNoRef;
426     }
427     /// ditto
428     @property inout(T) get(T : JSONValue[string])() inout pure @trusted
429     {
430         return object;
431     }
432     ///
433     @safe unittest
434     {
435         import std.exception;
436         import std.conv;
437         string s =
438         `{
439             "a": 123,
440             "b": 3.1415,
441             "c": "text",
442             "d": true,
443             "e": [1, 2, 3],
444             "f": { "a": 1 },
445             "g": -45,
446             "h": ` ~ ulong.max.to!string ~ `,
447          }`;
448 
449         struct a { }
450 
451         immutable json = parseJSON(s);
452         assert(json["a"].get!double == 123.0);
453         assert(json["a"].get!int == 123);
454         assert(json["a"].get!uint == 123);
455         assert(json["b"].get!double == 3.1415);
456         assertThrown!JSONException(json["b"].get!int);
457         assert(json["c"].get!string == "text");
458         assert(json["d"].get!bool == true);
459         assertNotThrown(json["e"].get!(JSONValue[]));
460         assertNotThrown(json["f"].get!(JSONValue[string]));
461         static assert(!__traits(compiles, json["a"].get!a));
462         assertThrown!JSONException(json["e"].get!float);
463         assertThrown!JSONException(json["d"].get!(JSONValue[string]));
464         assertThrown!JSONException(json["f"].get!(JSONValue[]));
465         assert(json["g"].get!int == -45);
466         assertThrown!ConvException(json["g"].get!uint);
467         assert(json["h"].get!ulong == ulong.max);
468         assertThrown!ConvException(json["h"].get!uint);
469         assertNotThrown(json["h"].get!float);
470     }
471 
472     private void assign(T)(T arg)
473     {
474         static if (is(T : typeof(null)))
475         {
476             type_tag = JSONType.null_;
477         }
478         else static if (is(T : string))
479         {
480             type_tag = JSONType..string;
481             string t = arg;
482             () @trusted { store.str = t; }();
483         }
484         // https://issues.dlang.org/show_bug.cgi?id=15884
485         else static if (isSomeString!T)
486         {
487             type_tag = JSONType..string;
488             // FIXME: std.Array.Array(Range) is not deduced as 'pure'
489             () @trusted {
490                 import std.utf : byUTF;
491                 store.str = cast(immutable)(arg.byUTF!char.array);
492             }();
493         }
494         else static if (is(T : bool))
495         {
496             type_tag = arg ? JSONType.true_ : JSONType.false_;
497         }
498         else static if (is(T : ulong) && isUnsigned!T)
499         {
500             type_tag = JSONType.uinteger;
501             store.uinteger = arg;
502         }
503         else static if (is(T : long))
504         {
505             type_tag = JSONType.integer;
506             store.integer = arg;
507         }
508         else static if (isFloatingPoint!T)
509         {
510             type_tag = JSONType.float_;
511             store.floating = arg;
512         }
513         else static if (is(T : Value[Key], Key, Value))
514         {
515             static assert(is(Key : string), "AA key must be string");
516             type_tag = JSONType.object;
517             static if (is(Value : JSONValue))
518             {
519                 JSONValue[string] t = arg;
520                 () @trusted { store.object = t; }();
521             }
522             else
523             {
524                 JSONValue[string] aa;
525                 foreach (key, value; arg)
526                     aa[key] = JSONValue(value);
527                 () @trusted { store.object = aa; }();
528             }
529         }
530         else static if (isArray!T)
531         {
532             type_tag = JSONType.array;
533             static if (is(ElementEncodingType!T : JSONValue))
534             {
535                 JSONValue[] t = arg;
536                 () @trusted { store.array = t; }();
537             }
538             else
539             {
540                 JSONValue[] new_arg = new JSONValue[arg.length];
541                 foreach (i, e; arg)
542                     new_arg[i] = JSONValue(e);
543                 () @trusted { store.array = new_arg; }();
544             }
545         }
546         else static if (is(T : JSONValue))
547         {
548             type_tag = arg.type;
549             store = arg.store;
550         }
551         else
552         {
553             static assert(false, text(`unable to convert type "`, T.stringof, `" to json`));
554         }
555     }
556 
557     private void assignRef(T)(ref T arg) if (isStaticArray!T)
558     {
559         type_tag = JSONType.array;
560         static if (is(ElementEncodingType!T : JSONValue))
561         {
562             store.array = arg;
563         }
564         else
565         {
566             JSONValue[] new_arg = new JSONValue[arg.length];
567             foreach (i, e; arg)
568                 new_arg[i] = JSONValue(e);
569             store.array = new_arg;
570         }
571     }
572 
573     /**
574      * Constructor for `JSONValue`. If `arg` is a `JSONValue`
575      * its value and type will be copied to the new `JSONValue`.
576      * Note that this is a shallow copy: if type is `JSONType.object`
577      * or `JSONType.array` then only the reference to the data will
578      * be copied.
579      * Otherwise, `arg` must be implicitly convertible to one of the
580      * following types: `typeof(null)`, `string`, `ulong`,
581      * `long`, `double`, an associative array `V[K]` for any `V`
582      * and `K` i.e. a JSON object, any array or `bool`. The type will
583      * be set accordingly.
584      */
585     this(T)(T arg) if (!isStaticArray!T)
586     {
587         assign(arg);
588     }
589     /// Ditto
590     this(T)(ref T arg) if (isStaticArray!T)
591     {
592         assignRef(arg);
593     }
594     /// Ditto
595     this(T : JSONValue)(inout T arg) inout
596     {
597         store = arg.store;
598         type_tag = arg.type;
599     }
600     ///
601     @safe unittest
602     {
603         JSONValue j = JSONValue( "a string" );
604         j = JSONValue(42);
605 
606         j = JSONValue( [1, 2, 3] );
607         assert(j.type == JSONType.array);
608 
609         j = JSONValue( ["language": "D"] );
610         assert(j.type == JSONType.object);
611     }
612 
613     /**
614      * An enum value that can be used to obtain a `JSONValue` representing
615      * an empty JSON object.
616      */
617     enum emptyObject = JSONValue(string[string].init);
618     ///
619     @system unittest
620     {
621         JSONValue obj1 = JSONValue.emptyObject;
622         assert(obj1.type == JSONType.object);
623         obj1.object["a"] = JSONValue(1);
624         assert(obj1.object["a"] == JSONValue(1));
625 
626         JSONValue obj2 = JSONValue.emptyObject;
627         assert("a" !in obj2.object);
628         obj2.object["b"] = JSONValue(5);
629         assert(obj1 != obj2);
630     }
631 
632     /**
633      * An enum value that can be used to obtain a `JSONValue` representing
634      * an empty JSON array.
635      */
636     enum emptyArray = JSONValue(JSONValue[].init);
637     ///
638     @system unittest
639     {
640         JSONValue arr1 = JSONValue.emptyArray;
641         assert(arr1.type == JSONType.array);
642         assert(arr1.array.length == 0);
643         arr1.array ~= JSONValue("Hello");
644         assert(arr1.array.length == 1);
645         assert(arr1.array[0] == JSONValue("Hello"));
646 
647         JSONValue arr2 = JSONValue.emptyArray;
648         assert(arr2.array.length == 0);
649         assert(arr1 != arr2);
650     }
651 
652     void opAssign(T)(T arg) if (!isStaticArray!T && !is(T : JSONValue))
653     {
654         assign(arg);
655     }
656 
657     void opAssign(T)(ref T arg) if (isStaticArray!T)
658     {
659         assignRef(arg);
660     }
661 
662     /***
663      * Array syntax for JSON arrays.
664      * Throws: `JSONException` if `type` is not `JSONType.array`.
665      */
666     ref inout(JSONValue) opIndex(size_t i) inout pure @safe
667     {
668         auto a = this.arrayNoRef;
669         enforce!JSONException(i < a.length,
670                                 "JSONValue array index is out of range");
671         return a[i];
672     }
673     ///
674     @safe unittest
675     {
676         JSONValue j = JSONValue( [42, 43, 44] );
677         assert( j[0].integer == 42 );
678         assert( j[1].integer == 43 );
679     }
680 
681     /***
682      * Hash syntax for JSON objects.
683      * Throws: `JSONException` if `type` is not `JSONType.object`.
684      */
685     ref inout(JSONValue) opIndex(return scope string k) inout pure @safe
686     {
687         auto o = this.objectNoRef;
688         return *enforce!JSONException(k in o,
689                                         "Key not found: " ~ k);
690     }
691     ///
692     @safe unittest
693     {
694         JSONValue j = JSONValue( ["language": "D"] );
695         assert( j["language"].str == "D" );
696     }
697 
698     /***
699      * Provides support for index assignments, which sets the
700      * corresponding value of the JSON object's `key` field to `value`.
701      *
702      * If the `JSONValue` is `JSONType.null_`, then this function
703      * initializes it with a JSON object and then performs
704      * the index assignment.
705      *
706      * Throws: `JSONException` if `type` is not `JSONType.object`
707      * or `JSONType.null_`.
708      */
709     void opIndexAssign(T)(auto ref T value, string key)
710     {
711         enforce!JSONException(type == JSONType.object || type == JSONType.null_,
712                                 "JSONValue must be object or null");
713         JSONValue[string] aa = null;
714         if (type == JSONType.object)
715         {
716             aa = this.objectNoRef;
717         }
718 
719         aa[key] = value;
720         this.object = aa;
721     }
722     ///
723     @safe unittest
724     {
725             JSONValue j = JSONValue( ["language": "D"] );
726             j["language"].str = "Perl";
727             assert( j["language"].str == "Perl" );
728     }
729 
730     /// ditto
731     void opIndexAssign(T)(T arg, size_t i)
732     {
733         auto a = this.arrayNoRef;
734         enforce!JSONException(i < a.length,
735                                 "JSONValue array index is out of range");
736         a[i] = arg;
737         this.array = a;
738     }
739     ///
740     @safe unittest
741     {
742             JSONValue j = JSONValue( ["Perl", "C"] );
743             j[1].str = "D";
744             assert( j[1].str == "D" );
745     }
746 
747     JSONValue opBinary(string op : "~", T)(T arg)
748     {
749         auto a = this.arrayNoRef;
750         static if (isArray!T)
751         {
752             return JSONValue(a ~ JSONValue(arg).arrayNoRef);
753         }
754         else static if (is(T : JSONValue))
755         {
756             return JSONValue(a ~ arg.arrayNoRef);
757         }
758         else
759         {
760             static assert(false, "argument is not an array or a JSONValue array");
761         }
762     }
763 
764     void opOpAssign(string op : "~", T)(T arg)
765     {
766         auto a = this.arrayNoRef;
767         static if (isArray!T)
768         {
769             a ~= JSONValue(arg).arrayNoRef;
770         }
771         else static if (is(T : JSONValue))
772         {
773             a ~= arg.arrayNoRef;
774         }
775         else
776         {
777             static assert(false, "argument is not an array or a JSONValue array");
778         }
779         this.array = a;
780     }
781 
782     /**
783      * Provides support for the `in` operator.
784      *
785      * Tests whether a key can be found in an object.
786      *
787      * Returns:
788      *      When found, the `inout(JSONValue)*` that matches to the key,
789      *      otherwise `null`.
790      *
791      * Throws: `JSONException` if the right hand side argument `JSONType`
792      * is not `object`.
793      */
794     inout(JSONValue)* opBinaryRight(string op : "in")(string k) inout @safe
795     {
796         return k in this.objectNoRef;
797     }
798     ///
799     @safe unittest
800     {
801         JSONValue j = [ "language": "D", "author": "walter" ];
802         string a = ("author" in j).str;
803         *("author" in j) = "Walter";
804         assert(j["author"].str == "Walter");
805     }
806 
807     ///
808     bool opEquals(const JSONValue rhs) const @nogc nothrow pure @safe
809     {
810         return opEquals(rhs);
811     }
812 
813     /// ditto
814     bool opEquals(ref const JSONValue rhs) const @nogc nothrow pure @trusted
815     {
816         // Default doesn't work well since store is a union.  Compare only
817         // what should be in store.
818         // This is @trusted to remain nogc, nothrow, fast, and usable from @safe code.
819 
820         final switch (type_tag)
821         {
822         case JSONType.integer:
823             switch (rhs.type_tag)
824             {
825                 case JSONType.integer:
826                     return store.integer == rhs.store.integer;
827                 case JSONType.uinteger:
828                     return store.integer == rhs.store.uinteger;
829                 case JSONType.float_:
830                     return store.integer == rhs.store.floating;
831                 default:
832                     return false;
833             }
834         case JSONType.uinteger:
835             switch (rhs.type_tag)
836             {
837                 case JSONType.integer:
838                     return store.uinteger == rhs.store.integer;
839                 case JSONType.uinteger:
840                     return store.uinteger == rhs.store.uinteger;
841                 case JSONType.float_:
842                     return store.uinteger == rhs.store.floating;
843                 default:
844                     return false;
845             }
846         case JSONType.float_:
847             switch (rhs.type_tag)
848             {
849                 case JSONType.integer:
850                     return store.floating == rhs.store.integer;
851                 case JSONType.uinteger:
852                     return store.floating == rhs.store.uinteger;
853                 case JSONType.float_:
854                     return store.floating == rhs.store.floating;
855                 default:
856                     return false;
857             }
858         case JSONType..string:
859             return type_tag == rhs.type_tag && store.str == rhs.store.str;
860         case JSONType.object:
861             return type_tag == rhs.type_tag && store.object == rhs.store.object;
862         case JSONType.array:
863             return type_tag == rhs.type_tag && store.array == rhs.store.array;
864         case JSONType.true_:
865         case JSONType.false_:
866         case JSONType.null_:
867             return type_tag == rhs.type_tag;
868         }
869     }
870 
871     ///
872     @safe unittest
873     {
874         assert(JSONValue(0u) == JSONValue(0));
875         assert(JSONValue(0u) == JSONValue(0.0));
876         assert(JSONValue(0) == JSONValue(0.0));
877     }
878 
879     /// Implements the foreach `opApply` interface for json arrays.
880     int opApply(scope int delegate(size_t index, ref JSONValue) dg) @system
881     {
882         int result;
883 
884         foreach (size_t index, ref value; array)
885         {
886             result = dg(index, value);
887             if (result)
888                 break;
889         }
890 
891         return result;
892     }
893 
894     /// Implements the foreach `opApply` interface for json objects.
895     int opApply(scope int delegate(string key, ref JSONValue) dg) @system
896     {
897         enforce!JSONException(type == JSONType.object,
898                                 "JSONValue is not an object");
899         int result;
900 
901         foreach (string key, ref value; object)
902         {
903             result = dg(key, value);
904             if (result)
905                 break;
906         }
907 
908         return result;
909     }
910 
911     /***
912      * Implicitly calls `toJSON` on this JSONValue.
913      *
914      * $(I options) can be used to tweak the conversion behavior.
915      */
916     string toString(in JSONOptions options = JSONOptions.none) const @safe
917     {
918         return toJSON(this, false, options);
919     }
920 
921     ///
922     void toString(Out)(Out sink, in JSONOptions options = JSONOptions.none) const
923     {
924         toJSON(sink, this, false, options);
925     }
926 
927     /***
928      * Implicitly calls `toJSON` on this JSONValue, like `toString`, but
929      * also passes $(I true) as $(I pretty) argument.
930      *
931      * $(I options) can be used to tweak the conversion behavior
932      */
933     string toPrettyString(in JSONOptions options = JSONOptions.none) const @safe
934     {
935         return toJSON(this, true, options);
936     }
937 
938     ///
939     void toPrettyString(Out)(Out sink, in JSONOptions options = JSONOptions.none) const
940     {
941         toJSON(sink, this, true, options);
942     }
943 }
944 
945 // https://issues.dlang.org/show_bug.cgi?id=20874
946 @system unittest
947 {
948     static struct MyCustomType
949     {
950         public string toString () const @system { return null; }
951         alias toString this;
952     }
953 
954     static struct B
955     {
956         public JSONValue asJSON() const @system { return JSONValue.init; }
957         alias asJSON this;
958     }
959 
960     if (false) // Just checking attributes
961     {
962         JSONValue json;
963         MyCustomType ilovedlang;
964         json = ilovedlang;
965         json["foo"] = ilovedlang;
966         auto s = ilovedlang in json;
967 
968         B b;
969         json ~= b;
970         json ~ b;
971     }
972 }
973 
974 /**
975 Parses a serialized string and returns a tree of JSON values.
976 Throws: $(LREF JSONException) if string does not follow the JSON grammar or the depth exceeds the max depth,
977         $(LREF ConvException) if a number in the input cannot be represented by a native D type.
978 Params:
979     json = json-formatted string to parse
980     maxDepth = maximum depth of nesting allowed, -1 disables depth checking
981     options = enable decoding string representations of NaN/Inf as float values
982 */
983 JSONValue parseJSON(T)(T json, int maxDepth = -1, JSONOptions options = JSONOptions.none)
984 if (isSomeFiniteCharInputRange!T)
985 {
986     import std.ascii : isDigit, isHexDigit, toUpper, toLower;
987     import std.typecons : Nullable, Yes;
988     JSONValue root;
989     root.type_tag = JSONType.null_;
990 
991     // Avoid UTF decoding when possible, as it is unnecessary when
992     // processing JSON.
993     static if (is(T : const(char)[]))
994         alias Char = char;
995     else
996         alias Char = Unqual!(ElementType!T);
997 
998     int depth = -1;
999     Nullable!Char next;
1000     int line = 1, pos = 0;
1001     immutable bool strict = (options & JSONOptions.strictParsing) != 0;
1002 
1003     void error(string msg)
1004     {
1005         throw new JSONException(msg, line, pos);
1006     }
1007 
1008     if (json.empty)
1009     {
1010         if (strict)
1011         {
1012             error("Empty JSON body");
1013         }
1014         return root;
1015     }
1016 
1017     bool isWhite(dchar c)
1018     {
1019         if (strict)
1020         {
1021             // RFC 7159 has a stricter definition of whitespace than general ASCII.
1022             return c == ' ' || c == '\t' || c == '\n' || c == '\r';
1023         }
1024         import std.ascii : isWhite;
1025         // Accept ASCII NUL as whitespace in non-strict mode.
1026         return c == 0 || isWhite(c);
1027     }
1028 
1029     Char popChar()
1030     {
1031         if (json.empty) error("Unexpected end of data.");
1032         static if (is(T : const(char)[]))
1033         {
1034             Char c = json[0];
1035             json = json[1..$];
1036         }
1037         else
1038         {
1039             Char c = json.front;
1040             json.popFront();
1041         }
1042 
1043         if (c == '\n')
1044         {
1045             line++;
1046             pos = 0;
1047         }
1048         else
1049         {
1050             pos++;
1051         }
1052 
1053         return c;
1054     }
1055 
1056     Char peekChar()
1057     {
1058         if (next.isNull)
1059         {
1060             if (json.empty) return '\0';
1061             next = popChar();
1062         }
1063         return next.get;
1064     }
1065 
1066     Nullable!Char peekCharNullable()
1067     {
1068         if (next.isNull && !json.empty)
1069         {
1070             next = popChar();
1071         }
1072         return next;
1073     }
1074 
1075     void skipWhitespace()
1076     {
1077         while (true)
1078         {
1079             auto c = peekCharNullable();
1080             if (c.isNull ||
1081                 !isWhite(c.get))
1082             {
1083                 return;
1084             }
1085             next.nullify();
1086         }
1087     }
1088 
1089     Char getChar(bool SkipWhitespace = false)()
1090     {
1091         static if (SkipWhitespace) skipWhitespace();
1092 
1093         Char c;
1094         if (!next.isNull)
1095         {
1096             c = next.get;
1097             next.nullify();
1098         }
1099         else
1100             c = popChar();
1101 
1102         return c;
1103     }
1104 
1105     void checkChar(bool SkipWhitespace = true)(char c, bool caseSensitive = true)
1106     {
1107         static if (SkipWhitespace) skipWhitespace();
1108         auto c2 = getChar();
1109         if (!caseSensitive) c2 = toLower(c2);
1110 
1111         if (c2 != c) error(text("Found '", c2, "' when expecting '", c, "'."));
1112     }
1113 
1114     bool testChar(bool SkipWhitespace = true, bool CaseSensitive = true)(char c)
1115     {
1116         static if (SkipWhitespace) skipWhitespace();
1117         auto c2 = peekChar();
1118         static if (!CaseSensitive) c2 = toLower(c2);
1119 
1120         if (c2 != c) return false;
1121 
1122         getChar();
1123         return true;
1124     }
1125 
1126     wchar parseWChar()
1127     {
1128         wchar val = 0;
1129         foreach_reverse (i; 0 .. 4)
1130         {
1131             auto hex = toUpper(getChar());
1132             if (!isHexDigit(hex)) error("Expecting hex character");
1133             val += (isDigit(hex) ? hex - '0' : hex - ('A' - 10)) << (4 * i);
1134         }
1135         return val;
1136     }
1137 
1138     string parseString()
1139     {
1140         import std.uni : isSurrogateHi, isSurrogateLo;
1141         import std.utf : encode, decode;
1142 
1143         auto str = appender!string();
1144 
1145     Next:
1146         switch (peekChar())
1147         {
1148             case '"':
1149                 getChar();
1150                 break;
1151 
1152             case '\\':
1153                 getChar();
1154                 auto c = getChar();
1155                 switch (c)
1156                 {
1157                     case '"':       str.put('"');   break;
1158                     case '\\':      str.put('\\');  break;
1159                     case '/':       str.put('/');   break;
1160                     case 'b':       str.put('\b');  break;
1161                     case 'f':       str.put('\f');  break;
1162                     case 'n':       str.put('\n');  break;
1163                     case 'r':       str.put('\r');  break;
1164                     case 't':       str.put('\t');  break;
1165                     case 'u':
1166                         wchar wc = parseWChar();
1167                         dchar val;
1168                         // Non-BMP characters are escaped as a pair of
1169                         // UTF-16 surrogate characters (see RFC 4627).
1170                         if (isSurrogateHi(wc))
1171                         {
1172                             wchar[2] pair;
1173                             pair[0] = wc;
1174                             if (getChar() != '\\') error("Expected escaped low surrogate after escaped high surrogate");
1175                             if (getChar() != 'u') error("Expected escaped low surrogate after escaped high surrogate");
1176                             pair[1] = parseWChar();
1177                             size_t index = 0;
1178                             val = decode(pair[], index);
1179                             if (index != 2) error("Invalid escaped surrogate pair");
1180                         }
1181                         else
1182                         if (isSurrogateLo(wc))
1183                             error(text("Unexpected low surrogate"));
1184                         else
1185                             val = wc;
1186 
1187                         char[4] buf;
1188                         immutable len = encode!(Yes.useReplacementDchar)(buf, val);
1189                         str.put(buf[0 .. len]);
1190                         break;
1191 
1192                     default:
1193                         error(text("Invalid escape sequence '\\", c, "'."));
1194                 }
1195                 goto Next;
1196 
1197             default:
1198                 // RFC 7159 states that control characters U+0000 through
1199                 // U+001F must not appear unescaped in a JSON string.
1200                 // Note: std.ascii.isControl can't be used for this test
1201                 // because it considers ASCII DEL (0x7f) to be a control
1202                 // character but RFC 7159 does not.
1203                 // Accept unescaped ASCII NULs in non-strict mode.
1204                 auto c = getChar();
1205                 if (c < 0x20 && (strict || c != 0))
1206                     error("Illegal control character.");
1207                 str.put(c);
1208                 goto Next;
1209         }
1210 
1211         return str.data.length ? str.data : "";
1212     }
1213 
1214     bool tryGetSpecialFloat(string str, out double val) {
1215         switch (str)
1216         {
1217             case JSONFloatLiteral.nan:
1218                 val = double.nan;
1219                 return true;
1220             case JSONFloatLiteral.inf:
1221                 val = double.infinity;
1222                 return true;
1223             case JSONFloatLiteral.negativeInf:
1224                 val = -double.infinity;
1225                 return true;
1226             default:
1227                 return false;
1228         }
1229     }
1230 
1231     void parseValue(ref JSONValue value)
1232     {
1233         depth++;
1234 
1235         if (maxDepth != -1 && depth > maxDepth) error("Nesting too deep.");
1236 
1237         auto c = getChar!true();
1238 
1239         switch (c)
1240         {
1241             case '{':
1242                 if (testChar('}'))
1243                 {
1244                     value.object = null;
1245                     break;
1246                 }
1247 
1248                 JSONValue[string] obj;
1249                 do
1250                 {
1251                     skipWhitespace();
1252                     if (!strict && peekChar() == '}')
1253                     {
1254                         break;
1255                     }
1256                     checkChar('"');
1257                     string name = parseString();
1258                     checkChar(':');
1259                     JSONValue member;
1260                     parseValue(member);
1261                     obj[name] = member;
1262                 }
1263                 while (testChar(','));
1264                 value.object = obj;
1265 
1266                 checkChar('}');
1267                 break;
1268 
1269             case '[':
1270                 if (testChar(']'))
1271                 {
1272                     value.type_tag = JSONType.array;
1273                     break;
1274                 }
1275 
1276                 JSONValue[] arr;
1277                 do
1278                 {
1279                     skipWhitespace();
1280                     if (!strict && peekChar() == ']')
1281                     {
1282                         break;
1283                     }
1284                     JSONValue element;
1285                     parseValue(element);
1286                     arr ~= element;
1287                 }
1288                 while (testChar(','));
1289 
1290                 checkChar(']');
1291                 value.array = arr;
1292                 break;
1293 
1294             case '"':
1295                 auto str = parseString();
1296 
1297                 // if special float parsing is enabled, check if string represents NaN/Inf
1298                 if ((options & JSONOptions.specialFloatLiterals) &&
1299                     tryGetSpecialFloat(str, value.store.floating))
1300                 {
1301                     // found a special float, its value was placed in value.store.floating
1302                     value.type_tag = JSONType.float_;
1303                     break;
1304                 }
1305 
1306                 value.assign(str);
1307                 break;
1308 
1309             case '0': .. case '9':
1310             case '-':
1311                 auto number = appender!string();
1312                 bool isFloat, isNegative;
1313 
1314                 void readInteger()
1315                 {
1316                     if (!isDigit(c)) error("Digit expected");
1317 
1318                 Next: number.put(c);
1319 
1320                     if (isDigit(peekChar()))
1321                     {
1322                         c = getChar();
1323                         goto Next;
1324                     }
1325                 }
1326 
1327                 if (c == '-')
1328                 {
1329                     number.put('-');
1330                     c = getChar();
1331                     isNegative = true;
1332                 }
1333 
1334                 if (strict && c == '0')
1335                 {
1336                     number.put('0');
1337                     if (isDigit(peekChar()))
1338                     {
1339                         error("Additional digits not allowed after initial zero digit");
1340                     }
1341                 }
1342                 else
1343                 {
1344                     readInteger();
1345                 }
1346 
1347                 if (testChar('.'))
1348                 {
1349                     isFloat = true;
1350                     number.put('.');
1351                     c = getChar();
1352                     readInteger();
1353                 }
1354                 if (testChar!(false, false)('e'))
1355                 {
1356                     isFloat = true;
1357                     number.put('e');
1358                     if (testChar('+')) number.put('+');
1359                     else if (testChar('-')) number.put('-');
1360                     c = getChar();
1361                     readInteger();
1362                 }
1363 
1364                 string data = number.data;
1365                 if (isFloat)
1366                 {
1367                     value.type_tag = JSONType.float_;
1368                     value.store.floating = parse!double(data);
1369                 }
1370                 else
1371                 {
1372                     if (isNegative)
1373                     {
1374                         value.store.integer = parse!long(data);
1375                         value.type_tag = JSONType.integer;
1376                     }
1377                     else
1378                     {
1379                         // only set the correct union member to not confuse CTFE
1380                         ulong u = parse!ulong(data);
1381                         if (u & (1UL << 63))
1382                         {
1383                             value.store.uinteger = u;
1384                             value.type_tag = JSONType.uinteger;
1385                         }
1386                         else
1387                         {
1388                             value.store.integer = u;
1389                             value.type_tag = JSONType.integer;
1390                         }
1391                     }
1392                 }
1393                 break;
1394 
1395             case 'T':
1396                 if (strict) goto default;
1397                 goto case;
1398             case 't':
1399                 value.type_tag = JSONType.true_;
1400                 checkChar!false('r', strict);
1401                 checkChar!false('u', strict);
1402                 checkChar!false('e', strict);
1403                 break;
1404 
1405             case 'F':
1406                 if (strict) goto default;
1407                 goto case;
1408             case 'f':
1409                 value.type_tag = JSONType.false_;
1410                 checkChar!false('a', strict);
1411                 checkChar!false('l', strict);
1412                 checkChar!false('s', strict);
1413                 checkChar!false('e', strict);
1414                 break;
1415 
1416             case 'N':
1417                 if (strict) goto default;
1418                 goto case;
1419             case 'n':
1420                 value.type_tag = JSONType.null_;
1421                 checkChar!false('u', strict);
1422                 checkChar!false('l', strict);
1423                 checkChar!false('l', strict);
1424                 break;
1425 
1426             default:
1427                 error(text("Unexpected character '", c, "'."));
1428         }
1429 
1430         depth--;
1431     }
1432 
1433     parseValue(root);
1434     if (strict)
1435     {
1436         skipWhitespace();
1437         if (!peekCharNullable().isNull) error("Trailing non-whitespace characters");
1438     }
1439     return root;
1440 }
1441 
1442 @safe unittest
1443 {
1444     enum issue15742objectOfObject = `{ "key1": { "key2": 1 }}`;
1445     static assert(parseJSON(issue15742objectOfObject).type == JSONType.object);
1446 
1447     enum issue15742arrayOfArray = `[[1]]`;
1448     static assert(parseJSON(issue15742arrayOfArray).type == JSONType.array);
1449 }
1450 
1451 @safe unittest
1452 {
1453     // Ensure we can parse and use JSON from @safe code
1454     auto a = `{ "key1": { "key2": 1 }}`.parseJSON;
1455     assert(a["key1"]["key2"].integer == 1);
1456     assert(a.toString == `{"key1":{"key2":1}}`);
1457 }
1458 
1459 @system unittest
1460 {
1461     // Ensure we can parse JSON from a @system range.
1462     struct Range
1463     {
1464         string s;
1465         size_t index;
1466         @system
1467         {
1468             bool empty() { return index >= s.length; }
1469             void popFront() { index++; }
1470             char front() { return s[index]; }
1471         }
1472     }
1473     auto s = Range(`{ "key1": { "key2": 1 }}`);
1474     auto json = parseJSON(s);
1475     assert(json["key1"]["key2"].integer == 1);
1476 }
1477 
1478 // https://issues.dlang.org/show_bug.cgi?id=20527
1479 @safe unittest
1480 {
1481     static assert(parseJSON(`{"a" : 2}`)["a"].integer == 2);
1482 }
1483 
1484 /**
1485 Parses a serialized string and returns a tree of JSON values.
1486 Throws: $(LREF JSONException) if the depth exceeds the max depth.
1487 Params:
1488     json = json-formatted string to parse
1489     options = enable decoding string representations of NaN/Inf as float values
1490 */
1491 JSONValue parseJSON(T)(T json, JSONOptions options)
1492 if (isSomeFiniteCharInputRange!T)
1493 {
1494     return parseJSON!T(json, -1, options);
1495 }
1496 
1497 /**
1498 Takes a tree of JSON values and returns the serialized string.
1499 
1500 Any Object types will be serialized in a key-sorted order.
1501 
1502 If `pretty` is false no whitespaces are generated.
1503 If `pretty` is true serialized string is formatted to be human-readable.
1504 Set the $(LREF JSONOptions.specialFloatLiterals) flag is set in `options` to encode NaN/Infinity as strings.
1505 */
1506 string toJSON(const ref JSONValue root, in bool pretty = false, in JSONOptions options = JSONOptions.none) @safe
1507 {
1508     auto json = appender!string();
1509     toJSON(json, root, pretty, options);
1510     return json.data;
1511 }
1512 
1513 ///
1514 void toJSON(Out)(
1515     auto ref Out json,
1516     const ref JSONValue root,
1517     in bool pretty = false,
1518     in JSONOptions options = JSONOptions.none)
1519 if (isOutputRange!(Out,char))
1520 {
1521     void toStringImpl(Char)(string str)
1522     {
1523         json.put('"');
1524 
1525         foreach (Char c; str)
1526         {
1527             switch (c)
1528             {
1529                 case '"':       json.put("\\\"");       break;
1530                 case '\\':      json.put("\\\\");       break;
1531 
1532                 case '/':
1533                     if (!(options & JSONOptions.doNotEscapeSlashes))
1534                         json.put('\\');
1535                     json.put('/');
1536                     break;
1537 
1538                 case '\b':      json.put("\\b");        break;
1539                 case '\f':      json.put("\\f");        break;
1540                 case '\n':      json.put("\\n");        break;
1541                 case '\r':      json.put("\\r");        break;
1542                 case '\t':      json.put("\\t");        break;
1543                 default:
1544                 {
1545                     import std.ascii : isControl;
1546                     import std.utf : encode;
1547 
1548                     // Make sure we do UTF decoding iff we want to
1549                     // escape Unicode characters.
1550                     assert(((options & JSONOptions.escapeNonAsciiChars) != 0)
1551                         == is(Char == dchar), "JSONOptions.escapeNonAsciiChars needs dchar strings");
1552 
1553                     with (JSONOptions) if (isControl(c) ||
1554                         ((options & escapeNonAsciiChars) >= escapeNonAsciiChars && c >= 0x80))
1555                     {
1556                         // Ensure non-BMP characters are encoded as a pair
1557                         // of UTF-16 surrogate characters, as per RFC 4627.
1558                         wchar[2] wchars; // 1 or 2 UTF-16 code units
1559                         size_t wNum = encode(wchars, c); // number of UTF-16 code units
1560                         foreach (wc; wchars[0 .. wNum])
1561                         {
1562                             json.put("\\u");
1563                             foreach_reverse (i; 0 .. 4)
1564                             {
1565                                 char ch = (wc >>> (4 * i)) & 0x0f;
1566                                 ch += ch < 10 ? '0' : 'A' - 10;
1567                                 json.put(ch);
1568                             }
1569                         }
1570                     }
1571                     else
1572                     {
1573                         json.put(c);
1574                     }
1575                 }
1576             }
1577         }
1578 
1579         json.put('"');
1580     }
1581 
1582     void toString(string str)
1583     {
1584         // Avoid UTF decoding when possible, as it is unnecessary when
1585         // processing JSON.
1586         if (options & JSONOptions.escapeNonAsciiChars)
1587             toStringImpl!dchar(str);
1588         else
1589             toStringImpl!char(str);
1590     }
1591 
1592     /* make the function infer @system when json.put() is @system
1593      */
1594     if (0)
1595         json.put(' ');
1596 
1597     /* Mark as @trusted because json.put() may be @system. This has difficulty
1598      * inferring @safe because it is recursive.
1599      */
1600     void toValueImpl(ref const JSONValue value, ulong indentLevel) @trusted
1601     {
1602         void putTabs(ulong additionalIndent = 0)
1603         {
1604             if (pretty)
1605                 foreach (i; 0 .. indentLevel + additionalIndent)
1606                     json.put("    ");
1607         }
1608         void putEOL()
1609         {
1610             if (pretty)
1611                 json.put('\n');
1612         }
1613         void putCharAndEOL(char ch)
1614         {
1615             json.put(ch);
1616             putEOL();
1617         }
1618 
1619         final switch (value.type)
1620         {
1621             case JSONType.object:
1622                 auto obj = value.objectNoRef;
1623                 if (!obj.length)
1624                 {
1625                     json.put("{}");
1626                 }
1627                 else
1628                 {
1629                     putCharAndEOL('{');
1630                     bool first = true;
1631 
1632                     void emit(R)(R names)
1633                     {
1634                         foreach (name; names)
1635                         {
1636                             auto member = obj[name];
1637                             if (!first)
1638                                 putCharAndEOL(',');
1639                             first = false;
1640                             putTabs(1);
1641                             toString(name);
1642                             json.put(':');
1643                             if (pretty)
1644                                 json.put(' ');
1645                             toValueImpl(member, indentLevel + 1);
1646                         }
1647                     }
1648 
1649                     import std.algorithm.sorting : sort;
1650                     // https://issues.dlang.org/show_bug.cgi?id=14439
1651                     // auto names = obj.keys;  // aa.keys can't be called in @safe code
1652                     auto names = new string[obj.length];
1653                     size_t i = 0;
1654                     foreach (k, v; obj)
1655                     {
1656                         names[i] = k;
1657                         i++;
1658                     }
1659                     sort(names);
1660                     emit(names);
1661 
1662                     putEOL();
1663                     putTabs();
1664                     json.put('}');
1665                 }
1666                 break;
1667 
1668             case JSONType.array:
1669                 auto arr = value.arrayNoRef;
1670                 if (arr.empty)
1671                 {
1672                     json.put("[]");
1673                 }
1674                 else
1675                 {
1676                     putCharAndEOL('[');
1677                     foreach (i, el; arr)
1678                     {
1679                         if (i)
1680                             putCharAndEOL(',');
1681                         putTabs(1);
1682                         toValueImpl(el, indentLevel + 1);
1683                     }
1684                     putEOL();
1685                     putTabs();
1686                     json.put(']');
1687                 }
1688                 break;
1689 
1690             case JSONType..string:
1691                 toString(value.str);
1692                 break;
1693 
1694             case JSONType.integer:
1695                 json.put(to!string(value.store.integer));
1696                 break;
1697 
1698             case JSONType.uinteger:
1699                 json.put(to!string(value.store.uinteger));
1700                 break;
1701 
1702             case JSONType.float_:
1703                 import std.math.traits : isNaN, isInfinity;
1704 
1705                 auto val = value.store.floating;
1706 
1707                 if (val.isNaN)
1708                 {
1709                     if (options & JSONOptions.specialFloatLiterals)
1710                     {
1711                         toString(JSONFloatLiteral.nan);
1712                     }
1713                     else
1714                     {
1715                         throw new JSONException(
1716                             "Cannot encode NaN. Consider passing the specialFloatLiterals flag.");
1717                     }
1718                 }
1719                 else if (val.isInfinity)
1720                 {
1721                     if (options & JSONOptions.specialFloatLiterals)
1722                     {
1723                         toString((val > 0) ?  JSONFloatLiteral.inf : JSONFloatLiteral.negativeInf);
1724                     }
1725                     else
1726                     {
1727                         throw new JSONException(
1728                             "Cannot encode Infinity. Consider passing the specialFloatLiterals flag.");
1729                     }
1730                 }
1731                 else
1732                 {
1733                     import std.algorithm.searching : canFind;
1734                     import std.format : sformat;
1735                     // The correct formula for the number of decimal digits needed for lossless round
1736                     // trips is actually:
1737                     //     ceil(log(pow(2.0, double.mant_dig - 1)) / log(10.0) + 1) == (double.dig + 2)
1738                     // Anything less will round off (1 + double.epsilon)
1739                     char[25] buf;
1740                     auto result = buf[].sformat!"%.18g"(val);
1741                     json.put(result);
1742                     if (!result.canFind('e') && !result.canFind('.'))
1743                         json.put(".0");
1744                 }
1745                 break;
1746 
1747             case JSONType.true_:
1748                 json.put("true");
1749                 break;
1750 
1751             case JSONType.false_:
1752                 json.put("false");
1753                 break;
1754 
1755             case JSONType.null_:
1756                 json.put("null");
1757                 break;
1758         }
1759     }
1760 
1761     toValueImpl(root, 0);
1762 }
1763 
1764  // https://issues.dlang.org/show_bug.cgi?id=12897
1765 @safe unittest
1766 {
1767     JSONValue jv0 = JSONValue("test测试");
1768     assert(toJSON(jv0, false, JSONOptions.escapeNonAsciiChars) == `"test\u6D4B\u8BD5"`);
1769     JSONValue jv00 = JSONValue("test\u6D4B\u8BD5");
1770     assert(toJSON(jv00, false, JSONOptions.none) == `"test测试"`);
1771     assert(toJSON(jv0, false, JSONOptions.none) == `"test测试"`);
1772     JSONValue jv1 = JSONValue("été");
1773     assert(toJSON(jv1, false, JSONOptions.escapeNonAsciiChars) == `"\u00E9t\u00E9"`);
1774     JSONValue jv11 = JSONValue("\u00E9t\u00E9");
1775     assert(toJSON(jv11, false, JSONOptions.none) == `"été"`);
1776     assert(toJSON(jv1, false, JSONOptions.none) == `"été"`);
1777 }
1778 
1779 // https://issues.dlang.org/show_bug.cgi?id=20511
1780 @system unittest
1781 {
1782     import std.format.write : formattedWrite;
1783     import std.range : nullSink, outputRangeObject;
1784 
1785     outputRangeObject!(const(char)[])(nullSink)
1786         .formattedWrite!"%s"(JSONValue.init);
1787 }
1788 
1789 // Issue 16432 - JSON incorrectly parses to string
1790 @safe unittest
1791 {
1792     // Floating points numbers are rounded to the nearest integer and thus get
1793     // incorrectly parsed
1794 
1795     import std.math.operations : isClose;
1796 
1797     string s = "{\"rating\": 3.0 }";
1798     JSONValue j = parseJSON(s);
1799     assert(j["rating"].type == JSONType.float_);
1800     j = j.toString.parseJSON;
1801     assert(j["rating"].type == JSONType.float_);
1802     assert(isClose(j["rating"].floating, 3.0));
1803 
1804     s = "{\"rating\": -3.0 }";
1805     j = parseJSON(s);
1806     assert(j["rating"].type == JSONType.float_);
1807     j = j.toString.parseJSON;
1808     assert(j["rating"].type == JSONType.float_);
1809     assert(isClose(j["rating"].floating, -3.0));
1810 
1811     // https://issues.dlang.org/show_bug.cgi?id=13660
1812     auto jv1 = JSONValue(4.0);
1813     auto textual = jv1.toString();
1814     auto jv2 = parseJSON(textual);
1815     assert(jv1.type == JSONType.float_);
1816     assert(textual == "4.0");
1817     assert(jv2.type == JSONType.float_);
1818 }
1819 
1820 @safe unittest
1821 {
1822     // Adapted from https://github.com/dlang/phobos/pull/5005
1823     // Result from toString is not checked here, because this
1824     // might differ (%e-like or %f-like output) depending
1825     // on OS and compiler optimization.
1826     import std.math.operations : isClose;
1827 
1828     // test positive extreme values
1829     JSONValue j;
1830     j["rating"] = 1e18 - 65;
1831     assert(isClose(j.toString.parseJSON["rating"].floating, 1e18 - 65));
1832 
1833     j["rating"] = 1e18 - 64;
1834     assert(isClose(j.toString.parseJSON["rating"].floating, 1e18 - 64));
1835 
1836     // negative extreme values
1837     j["rating"] = -1e18 + 65;
1838     assert(isClose(j.toString.parseJSON["rating"].floating, -1e18 + 65));
1839 
1840     j["rating"] = -1e18 + 64;
1841     assert(isClose(j.toString.parseJSON["rating"].floating, -1e18 + 64));
1842 }
1843 
1844 /**
1845 Exception thrown on JSON errors
1846 */
1847 class JSONException : Exception
1848 {
1849     this(string msg, int line = 0, int pos = 0) pure nothrow @safe
1850     {
1851         if (line)
1852             super(text(msg, " (Line ", line, ":", pos, ")"));
1853         else
1854             super(msg);
1855     }
1856 
1857     this(string msg, string file, size_t line) pure nothrow @safe
1858     {
1859         super(msg, file, line);
1860     }
1861 }
1862 
1863 
1864 @system unittest
1865 {
1866     import std.exception;
1867     JSONValue jv = "123";
1868     assert(jv.type == JSONType..string);
1869     assertNotThrown(jv.str);
1870     assertThrown!JSONException(jv.integer);
1871     assertThrown!JSONException(jv.uinteger);
1872     assertThrown!JSONException(jv.floating);
1873     assertThrown!JSONException(jv.object);
1874     assertThrown!JSONException(jv.array);
1875     assertThrown!JSONException(jv["aa"]);
1876     assertThrown!JSONException(jv[2]);
1877 
1878     jv = -3;
1879     assert(jv.type == JSONType.integer);
1880     assertNotThrown(jv.integer);
1881 
1882     jv = cast(uint) 3;
1883     assert(jv.type == JSONType.uinteger);
1884     assertNotThrown(jv.uinteger);
1885 
1886     jv = 3.0;
1887     assert(jv.type == JSONType.float_);
1888     assertNotThrown(jv.floating);
1889 
1890     jv = ["key" : "value"];
1891     assert(jv.type == JSONType.object);
1892     assertNotThrown(jv.object);
1893     assertNotThrown(jv["key"]);
1894     assert("key" in jv);
1895     assert("notAnElement" !in jv);
1896     assertThrown!JSONException(jv["notAnElement"]);
1897     const cjv = jv;
1898     assert("key" in cjv);
1899     assertThrown!JSONException(cjv["notAnElement"]);
1900 
1901     foreach (string key, value; jv)
1902     {
1903         static assert(is(typeof(value) == JSONValue));
1904         assert(key == "key");
1905         assert(value.type == JSONType..string);
1906         assertNotThrown(value.str);
1907         assert(value.str == "value");
1908     }
1909 
1910     jv = [3, 4, 5];
1911     assert(jv.type == JSONType.array);
1912     assertNotThrown(jv.array);
1913     assertNotThrown(jv[2]);
1914     foreach (size_t index, value; jv)
1915     {
1916         static assert(is(typeof(value) == JSONValue));
1917         assert(value.type == JSONType.integer);
1918         assertNotThrown(value.integer);
1919         assert(index == (value.integer-3));
1920     }
1921 
1922     jv = null;
1923     assert(jv.type == JSONType.null_);
1924     assert(jv.isNull);
1925     jv = "foo";
1926     assert(!jv.isNull);
1927 
1928     jv = JSONValue("value");
1929     assert(jv.type == JSONType..string);
1930     assert(jv.str == "value");
1931 
1932     JSONValue jv2 = JSONValue("value");
1933     assert(jv2.type == JSONType..string);
1934     assert(jv2.str == "value");
1935 
1936     JSONValue jv3 = JSONValue("\u001c");
1937     assert(jv3.type == JSONType..string);
1938     assert(jv3.str == "\u001C");
1939 }
1940 
1941 // https://issues.dlang.org/show_bug.cgi?id=11504
1942 @system unittest
1943 {
1944     JSONValue jv = 1;
1945     assert(jv.type == JSONType.integer);
1946 
1947     jv.str = "123";
1948     assert(jv.type == JSONType..string);
1949     assert(jv.str == "123");
1950 
1951     jv.integer = 1;
1952     assert(jv.type == JSONType.integer);
1953     assert(jv.integer == 1);
1954 
1955     jv.uinteger = 2u;
1956     assert(jv.type == JSONType.uinteger);
1957     assert(jv.uinteger == 2u);
1958 
1959     jv.floating = 1.5;
1960     assert(jv.type == JSONType.float_);
1961     assert(jv.floating == 1.5);
1962 
1963     jv.object = ["key" : JSONValue("value")];
1964     assert(jv.type == JSONType.object);
1965     assert(jv.object == ["key" : JSONValue("value")]);
1966 
1967     jv.array = [JSONValue(1), JSONValue(2), JSONValue(3)];
1968     assert(jv.type == JSONType.array);
1969     assert(jv.array == [JSONValue(1), JSONValue(2), JSONValue(3)]);
1970 
1971     jv = true;
1972     assert(jv.type == JSONType.true_);
1973 
1974     jv = false;
1975     assert(jv.type == JSONType.false_);
1976 
1977     enum E{True = true}
1978     jv = E.True;
1979     assert(jv.type == JSONType.true_);
1980 }
1981 
1982 @system pure unittest
1983 {
1984     // Adding new json element via array() / object() directly
1985 
1986     JSONValue jarr = JSONValue([10]);
1987     foreach (i; 0 .. 9)
1988         jarr.array ~= JSONValue(i);
1989     assert(jarr.array.length == 10);
1990 
1991     JSONValue jobj = JSONValue(["key" : JSONValue("value")]);
1992     foreach (i; 0 .. 9)
1993         jobj.object[text("key", i)] = JSONValue(text("value", i));
1994     assert(jobj.object.length == 10);
1995 }
1996 
1997 @system pure unittest
1998 {
1999     // Adding new json element without array() / object() access
2000 
2001     JSONValue jarr = JSONValue([10]);
2002     foreach (i; 0 .. 9)
2003         jarr ~= [JSONValue(i)];
2004     assert(jarr.array.length == 10);
2005 
2006     JSONValue jobj = JSONValue(["key" : JSONValue("value")]);
2007     foreach (i; 0 .. 9)
2008         jobj[text("key", i)] = JSONValue(text("value", i));
2009     assert(jobj.object.length == 10);
2010 
2011     // No array alias
2012     auto jarr2 = jarr ~ [1,2,3];
2013     jarr2[0] = 999;
2014     assert(jarr[0] == JSONValue(10));
2015 }
2016 
2017 @system unittest
2018 {
2019     // @system because JSONValue.array is @system
2020     import std.exception;
2021 
2022     // An overly simple test suite, if it can parse a serializated string and
2023     // then use the resulting values tree to generate an identical
2024     // serialization, both the decoder and encoder works.
2025 
2026     auto jsons = [
2027         `null`,
2028         `true`,
2029         `false`,
2030         `0`,
2031         `123`,
2032         `-4321`,
2033         `0.25`,
2034         `-0.25`,
2035         `""`,
2036         `"hello\nworld"`,
2037         `"\"\\\/\b\f\n\r\t"`,
2038         `[]`,
2039         `[12,"foo",true,false]`,
2040         `{}`,
2041         `{"a":1,"b":null}`,
2042         `{"goodbye":[true,"or",false,["test",42,{"nested":{"a":23.5,"b":0.140625}}]],`
2043         ~`"hello":{"array":[12,null,{}],"json":"is great"}}`,
2044     ];
2045 
2046     enum dbl1_844 = `1.8446744073709568`;
2047     version (MinGW)
2048         jsons ~= dbl1_844 ~ `e+019`;
2049     else
2050         jsons ~= dbl1_844 ~ `e+19`;
2051 
2052     JSONValue val;
2053     string result;
2054     foreach (json; jsons)
2055     {
2056         try
2057         {
2058             val = parseJSON(json);
2059             enum pretty = false;
2060             result = toJSON(val, pretty);
2061             assert(result == json, text(result, " should be ", json));
2062         }
2063         catch (JSONException e)
2064         {
2065             import std.stdio : writefln;
2066             writefln(text(json, "\n", e.toString()));
2067         }
2068     }
2069 
2070     // Should be able to correctly interpret unicode entities
2071     val = parseJSON(`"\u003C\u003E"`);
2072     assert(toJSON(val) == "\"\&lt;\&gt;\"");
2073     assert(val.to!string() == "\"\&lt;\&gt;\"");
2074     val = parseJSON(`"\u0391\u0392\u0393"`);
2075     assert(toJSON(val) == "\"\&Alpha;\&Beta;\&Gamma;\"");
2076     assert(val.to!string() == "\"\&Alpha;\&Beta;\&Gamma;\"");
2077     val = parseJSON(`"\u2660\u2666"`);
2078     assert(toJSON(val) == "\"\&spades;\&diams;\"");
2079     assert(val.to!string() == "\"\&spades;\&diams;\"");
2080 
2081     //0x7F is a control character (see Unicode spec)
2082     val = parseJSON(`"\u007F"`);
2083     assert(toJSON(val) == "\"\\u007F\"");
2084     assert(val.to!string() == "\"\\u007F\"");
2085 
2086     with(parseJSON(`""`))
2087         assert(str == "" && str !is null);
2088     with(parseJSON(`[]`))
2089         assert(!array.length);
2090 
2091     // Formatting
2092     val = parseJSON(`{"a":[null,{"x":1},{},[]]}`);
2093     assert(toJSON(val, true) == `{
2094     "a": [
2095         null,
2096         {
2097             "x": 1
2098         },
2099         {},
2100         []
2101     ]
2102 }`);
2103 }
2104 
2105 @safe unittest
2106 {
2107   auto json = `"hello\nworld"`;
2108   const jv = parseJSON(json);
2109   assert(jv.toString == json);
2110   assert(jv.toPrettyString == json);
2111 }
2112 
2113 @system pure unittest
2114 {
2115     // https://issues.dlang.org/show_bug.cgi?id=12969
2116 
2117     JSONValue jv;
2118     jv["int"] = 123;
2119 
2120     assert(jv.type == JSONType.object);
2121     assert("int" in jv);
2122     assert(jv["int"].integer == 123);
2123 
2124     jv["array"] = [1, 2, 3, 4, 5];
2125 
2126     assert(jv["array"].type == JSONType.array);
2127     assert(jv["array"][2].integer == 3);
2128 
2129     jv["str"] = "D language";
2130     assert(jv["str"].type == JSONType..string);
2131     assert(jv["str"].str == "D language");
2132 
2133     jv["bool"] = false;
2134     assert(jv["bool"].type == JSONType.false_);
2135 
2136     assert(jv.object.length == 4);
2137 
2138     jv = [5, 4, 3, 2, 1];
2139     assert(jv.type == JSONType.array);
2140     assert(jv[3].integer == 2);
2141 }
2142 
2143 @safe unittest
2144 {
2145     auto s = q"EOF
2146 [
2147   1,
2148   2,
2149   3,
2150   potato
2151 ]
2152 EOF";
2153 
2154     import std.exception;
2155 
2156     auto e = collectException!JSONException(parseJSON(s));
2157     assert(e.msg == "Unexpected character 'p'. (Line 5:3)", e.msg);
2158 }
2159 
2160 // handling of special float values (NaN, Inf, -Inf)
2161 @safe unittest
2162 {
2163     import std.exception : assertThrown;
2164     import std.math.traits : isNaN, isInfinity;
2165 
2166     // expected representations of NaN and Inf
2167     enum {
2168         nanString         = '"' ~ JSONFloatLiteral.nan         ~ '"',
2169         infString         = '"' ~ JSONFloatLiteral.inf         ~ '"',
2170         negativeInfString = '"' ~ JSONFloatLiteral.negativeInf ~ '"',
2171     }
2172 
2173     // with the specialFloatLiterals option, encode NaN/Inf as strings
2174     assert(JSONValue(float.nan).toString(JSONOptions.specialFloatLiterals)       == nanString);
2175     assert(JSONValue(double.infinity).toString(JSONOptions.specialFloatLiterals) == infString);
2176     assert(JSONValue(-real.infinity).toString(JSONOptions.specialFloatLiterals)  == negativeInfString);
2177 
2178     // without the specialFloatLiterals option, throw on encoding NaN/Inf
2179     assertThrown!JSONException(JSONValue(float.nan).toString);
2180     assertThrown!JSONException(JSONValue(double.infinity).toString);
2181     assertThrown!JSONException(JSONValue(-real.infinity).toString);
2182 
2183     // when parsing json with specialFloatLiterals option, decode special strings as floats
2184     JSONValue jvNan    = parseJSON(nanString, JSONOptions.specialFloatLiterals);
2185     JSONValue jvInf    = parseJSON(infString, JSONOptions.specialFloatLiterals);
2186     JSONValue jvNegInf = parseJSON(negativeInfString, JSONOptions.specialFloatLiterals);
2187 
2188     assert(jvNan.floating.isNaN);
2189     assert(jvInf.floating.isInfinity    && jvInf.floating > 0);
2190     assert(jvNegInf.floating.isInfinity && jvNegInf.floating < 0);
2191 
2192     // when parsing json without the specialFloatLiterals option, decode special strings as strings
2193     jvNan    = parseJSON(nanString);
2194     jvInf    = parseJSON(infString);
2195     jvNegInf = parseJSON(negativeInfString);
2196 
2197     assert(jvNan.str    == JSONFloatLiteral.nan);
2198     assert(jvInf.str    == JSONFloatLiteral.inf);
2199     assert(jvNegInf.str == JSONFloatLiteral.negativeInf);
2200 }
2201 
2202 pure nothrow @safe @nogc unittest
2203 {
2204     JSONValue testVal;
2205     testVal = "test";
2206     testVal = 10;
2207     testVal = 10u;
2208     testVal = 1.0;
2209     testVal = (JSONValue[string]).init;
2210     testVal = JSONValue[].init;
2211     testVal = null;
2212     assert(testVal.isNull);
2213 }
2214 
2215 // https://issues.dlang.org/show_bug.cgi?id=15884
2216 pure nothrow @safe unittest
2217 {
2218     import std.typecons;
2219     void Test(C)() {
2220         C[] a = ['x'];
2221         JSONValue testVal = a;
2222         assert(testVal.type == JSONType..string);
2223         testVal = a.idup;
2224         assert(testVal.type == JSONType..string);
2225     }
2226     Test!char();
2227     Test!wchar();
2228     Test!dchar();
2229 }
2230 
2231 // https://issues.dlang.org/show_bug.cgi?id=15885
2232 @safe unittest
2233 {
2234     enum bool realInDoublePrecision = real.mant_dig == double.mant_dig;
2235 
2236     static bool test(const double num0)
2237     {
2238         import std.math.operations : feqrel;
2239         const json0 = JSONValue(num0);
2240         const num1 = to!double(toJSON(json0));
2241         static if (realInDoublePrecision)
2242             return feqrel(num1, num0) >= (double.mant_dig - 1);
2243         else
2244             return num1 == num0;
2245     }
2246 
2247     assert(test( 0.23));
2248     assert(test(-0.23));
2249     assert(test(1.223e+24));
2250     assert(test(23.4));
2251     assert(test(0.0012));
2252     assert(test(30738.22));
2253 
2254     assert(test(1 + double.epsilon));
2255     assert(test(double.min_normal));
2256     static if (realInDoublePrecision)
2257         assert(test(-double.max / 2));
2258     else
2259         assert(test(-double.max));
2260 
2261     const minSub = double.min_normal * double.epsilon;
2262     assert(test(minSub));
2263     assert(test(3*minSub));
2264 }
2265 
2266 // https://issues.dlang.org/show_bug.cgi?id=17555
2267 @safe unittest
2268 {
2269     import std.exception : assertThrown;
2270 
2271     assertThrown!JSONException(parseJSON("\"a\nb\""));
2272 }
2273 
2274 // https://issues.dlang.org/show_bug.cgi?id=17556
2275 @safe unittest
2276 {
2277     auto v = JSONValue("\U0001D11E");
2278     auto j = toJSON(v, false, JSONOptions.escapeNonAsciiChars);
2279     assert(j == `"\uD834\uDD1E"`);
2280 }
2281 
2282 // https://issues.dlang.org/show_bug.cgi?id=5904
2283 @safe unittest
2284 {
2285     string s = `"\uD834\uDD1E"`;
2286     auto j = parseJSON(s);
2287     assert(j.str == "\U0001D11E");
2288 }
2289 
2290 // https://issues.dlang.org/show_bug.cgi?id=17557
2291 @safe unittest
2292 {
2293     assert(parseJSON("\"\xFF\"").str == "\xFF");
2294     assert(parseJSON("\"\U0001D11E\"").str == "\U0001D11E");
2295 }
2296 
2297 // https://issues.dlang.org/show_bug.cgi?id=17553
2298 @safe unittest
2299 {
2300     auto v = JSONValue("\xFF");
2301     assert(toJSON(v) == "\"\xFF\"");
2302 }
2303 
2304 @safe unittest
2305 {
2306     import std.utf;
2307     assert(parseJSON("\"\xFF\"".byChar).str == "\xFF");
2308     assert(parseJSON("\"\U0001D11E\"".byChar).str == "\U0001D11E");
2309 }
2310 
2311 // JSONOptions.doNotEscapeSlashes (https://issues.dlang.org/show_bug.cgi?id=17587)
2312 @safe unittest
2313 {
2314     assert(parseJSON(`"/"`).toString == `"\/"`);
2315     assert(parseJSON(`"\/"`).toString == `"\/"`);
2316     assert(parseJSON(`"/"`).toString(JSONOptions.doNotEscapeSlashes) == `"/"`);
2317     assert(parseJSON(`"\/"`).toString(JSONOptions.doNotEscapeSlashes) == `"/"`);
2318 }
2319 
2320 // JSONOptions.strictParsing (https://issues.dlang.org/show_bug.cgi?id=16639)
2321 @safe unittest
2322 {
2323     import std.exception : assertThrown;
2324 
2325     // Unescaped ASCII NULs
2326     assert(parseJSON("[\0]").type == JSONType.array);
2327     assertThrown!JSONException(parseJSON("[\0]", JSONOptions.strictParsing));
2328     assert(parseJSON("\"\0\"").str == "\0");
2329     assertThrown!JSONException(parseJSON("\"\0\"", JSONOptions.strictParsing));
2330 
2331     // Unescaped ASCII DEL (0x7f) in strings
2332     assert(parseJSON("\"\x7f\"").str == "\x7f");
2333     assert(parseJSON("\"\x7f\"", JSONOptions.strictParsing).str == "\x7f");
2334 
2335     // "true", "false", "null" case sensitivity
2336     assert(parseJSON("true").type == JSONType.true_);
2337     assert(parseJSON("true", JSONOptions.strictParsing).type == JSONType.true_);
2338     assert(parseJSON("True").type == JSONType.true_);
2339     assertThrown!JSONException(parseJSON("True", JSONOptions.strictParsing));
2340     assert(parseJSON("tRUE").type == JSONType.true_);
2341     assertThrown!JSONException(parseJSON("tRUE", JSONOptions.strictParsing));
2342 
2343     assert(parseJSON("false").type == JSONType.false_);
2344     assert(parseJSON("false", JSONOptions.strictParsing).type == JSONType.false_);
2345     assert(parseJSON("False").type == JSONType.false_);
2346     assertThrown!JSONException(parseJSON("False", JSONOptions.strictParsing));
2347     assert(parseJSON("fALSE").type == JSONType.false_);
2348     assertThrown!JSONException(parseJSON("fALSE", JSONOptions.strictParsing));
2349 
2350     assert(parseJSON("null").type == JSONType.null_);
2351     assert(parseJSON("null", JSONOptions.strictParsing).type == JSONType.null_);
2352     assert(parseJSON("Null").type == JSONType.null_);
2353     assertThrown!JSONException(parseJSON("Null", JSONOptions.strictParsing));
2354     assert(parseJSON("nULL").type == JSONType.null_);
2355     assertThrown!JSONException(parseJSON("nULL", JSONOptions.strictParsing));
2356 
2357     // Whitespace characters
2358     assert(parseJSON("[\f\v]").type == JSONType.array);
2359     assertThrown!JSONException(parseJSON("[\f\v]", JSONOptions.strictParsing));
2360     assert(parseJSON("[ \t\r\n]").type == JSONType.array);
2361     assert(parseJSON("[ \t\r\n]", JSONOptions.strictParsing).type == JSONType.array);
2362 
2363     // Empty input
2364     assert(parseJSON("").type == JSONType.null_);
2365     assertThrown!JSONException(parseJSON("", JSONOptions.strictParsing));
2366 
2367     // Numbers with leading '0's
2368     assert(parseJSON("01").integer == 1);
2369     assertThrown!JSONException(parseJSON("01", JSONOptions.strictParsing));
2370     assert(parseJSON("-01").integer == -1);
2371     assertThrown!JSONException(parseJSON("-01", JSONOptions.strictParsing));
2372     assert(parseJSON("0.01").floating == 0.01);
2373     assert(parseJSON("0.01", JSONOptions.strictParsing).floating == 0.01);
2374     assert(parseJSON("0e1").floating == 0);
2375     assert(parseJSON("0e1", JSONOptions.strictParsing).floating == 0);
2376 
2377     // Trailing characters after JSON value
2378     assert(parseJSON(`""asdf`).str == "");
2379     assertThrown!JSONException(parseJSON(`""asdf`, JSONOptions.strictParsing));
2380     assert(parseJSON("987\0").integer == 987);
2381     assertThrown!JSONException(parseJSON("987\0", JSONOptions.strictParsing));
2382     assert(parseJSON("987\0\0").integer == 987);
2383     assertThrown!JSONException(parseJSON("987\0\0", JSONOptions.strictParsing));
2384     assert(parseJSON("[]]").type == JSONType.array);
2385     assertThrown!JSONException(parseJSON("[]]", JSONOptions.strictParsing));
2386     assert(parseJSON("123 \t\r\n").integer == 123); // Trailing whitespace is OK
2387     assert(parseJSON("123 \t\r\n", JSONOptions.strictParsing).integer == 123);
2388 }
2389 
2390 @system unittest
2391 {
2392     import std.algorithm.iteration : map;
2393     import std.array : array;
2394     import std.exception : assertThrown;
2395 
2396     string s = `{ "a" : [1,2,3,], }`;
2397     JSONValue j = parseJSON(s);
2398     assert(j["a"].array().map!(i => i.integer()).array == [1,2,3]);
2399 
2400     assertThrown(parseJSON(s, -1, JSONOptions.strictParsing));
2401 }
2402 
2403 @system unittest
2404 {
2405     import std.algorithm.iteration : map;
2406     import std.array : array;
2407     import std.exception : assertThrown;
2408 
2409     string s = `{ "a" : { }  , }`;
2410     JSONValue j = parseJSON(s);
2411     assert("a" in j);
2412     auto t = j["a"].object();
2413     assert(t.empty);
2414 
2415     assertThrown(parseJSON(s, -1, JSONOptions.strictParsing));
2416 }
2417 
2418 // https://issues.dlang.org/show_bug.cgi?id=20330
2419 @safe unittest
2420 {
2421     import std.array : appender;
2422 
2423     string s = `{"a":[1,2,3]}`;
2424     JSONValue j = parseJSON(s);
2425 
2426     auto app = appender!string();
2427     j.toString(app);
2428 
2429     assert(app.data == s, app.data);
2430 }
2431 
2432 // https://issues.dlang.org/show_bug.cgi?id=20330
2433 @safe unittest
2434 {
2435     import std.array : appender;
2436     import std.format.write : formattedWrite;
2437 
2438     string s =
2439 `{
2440     "a": [
2441         1,
2442         2,
2443         3
2444     ]
2445 }`;
2446     JSONValue j = parseJSON(s);
2447 
2448     auto app = appender!string();
2449     j.toPrettyString(app);
2450 
2451     assert(app.data == s, app.data);
2452 }