ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/JSON-XS/XS.pm
(Generate patch)

Comparing JSON-XS/XS.pm (file contents):
Revision 1.124 by root, Sun Aug 9 16:01:39 2009 UTC vs.
Revision 1.142 by root, Fri Oct 25 19:57:42 2013 UTC

… …
64so, and even documents what "correct" means. 64so, and even documents what "correct" means.
65 65
66=item * round-trip integrity 66=item * round-trip integrity
67 67
68When you serialise a perl data structure using only data types supported 68When you serialise a perl data structure using only data types supported
69by JSON, the deserialised data structure is identical on the Perl level. 69by JSON and Perl, the deserialised data structure is identical on the Perl
70(e.g. the string "2.0" doesn't suddenly become "2" just because it looks 70level. (e.g. the string "2.0" doesn't suddenly become "2" just because
71like a number). There minor I<are> exceptions to this, read the MAPPING 71it looks like a number). There I<are> minor exceptions to this, read the
72section below to learn about those. 72MAPPING section below to learn about those.
73 73
74=item * strict checking of JSON correctness 74=item * strict checking of JSON correctness
75 75
76There is no guessing, no generating of illegal JSON texts by default, 76There is no guessing, no generating of illegal JSON texts by default,
77and only JSON is accepted as input by default (the latter is a security 77and only JSON is accepted as input by default (the latter is a security
… …
83this module usually compares favourably in terms of speed, too. 83this module usually compares favourably in terms of speed, too.
84 84
85=item * simple to use 85=item * simple to use
86 86
87This module has both a simple functional interface as well as an object 87This module has both a simple functional interface as well as an object
88oriented interface interface. 88oriented interface.
89 89
90=item * reasonably versatile output formats 90=item * reasonably versatile output formats
91 91
92You can choose between the most compact guaranteed-single-line format 92You can choose between the most compact guaranteed-single-line format
93possible (nice for simple line-based protocols), a pure-ASCII format 93possible (nice for simple line-based protocols), a pure-ASCII format
… …
101 101
102package JSON::XS; 102package JSON::XS;
103 103
104use common::sense; 104use common::sense;
105 105
106our $VERSION = '2.25'; 106our $VERSION = 2.34;
107our @ISA = qw(Exporter); 107our @ISA = qw(Exporter);
108 108
109our @EXPORT = qw(encode_json decode_json to_json from_json); 109our @EXPORT = qw(encode_json decode_json);
110
111sub to_json($) {
112 require Carp;
113 Carp::croak ("JSON::XS::to_json has been renamed to encode_json, either downgrade to pre-2.0 versions of JSON::XS or rename the call");
114}
115
116sub from_json($) {
117 require Carp;
118 Carp::croak ("JSON::XS::from_json has been renamed to decode_json, either downgrade to pre-2.0 versions of JSON::XS or rename the call");
119}
120 110
121use Exporter; 111use Exporter;
122use XSLoader; 112use XSLoader;
123 113
124=head1 FUNCTIONAL INTERFACE 114=head1 FUNCTIONAL INTERFACE
… …
432If C<$enable> is true (or missing), then the C<encode> method will output JSON objects 422If C<$enable> is true (or missing), then the C<encode> method will output JSON objects
433by sorting their keys. This is adding a comparatively high overhead. 423by sorting their keys. This is adding a comparatively high overhead.
434 424
435If C<$enable> is false, then the C<encode> method will output key-value 425If C<$enable> is false, then the C<encode> method will output key-value
436pairs in the order Perl stores them (which will likely change between runs 426pairs in the order Perl stores them (which will likely change between runs
437of the same script). 427of the same script, and can change even within the same run from 5.18
428onwards).
438 429
439This option is useful if you want the same data structure to be encoded as 430This option is useful if you want the same data structure to be encoded as
440the same JSON text (given the same overall settings). If it is disabled, 431the same JSON text (given the same overall settings). If it is disabled,
441the same hash might be encoded differently even if contains the same data, 432the same hash might be encoded differently even if contains the same data,
442as key-value pairs have no inherent ordering in Perl. 433as key-value pairs have no inherent ordering in Perl.
… …
666 657
667See SECURITY CONSIDERATIONS, below, for more info on why this is useful. 658See SECURITY CONSIDERATIONS, below, for more info on why this is useful.
668 659
669=item $json_text = $json->encode ($perl_scalar) 660=item $json_text = $json->encode ($perl_scalar)
670 661
671Converts the given Perl data structure (a simple scalar or a reference 662Converts the given Perl value or data structure to its JSON
672to a hash or array) to its JSON representation. Simple scalars will be 663representation. Croaks on error.
673converted into JSON string or number sequences, while references to arrays
674become JSON arrays and references to hashes become JSON objects. Undefined
675Perl values (e.g. C<undef>) become JSON C<null> values. Neither C<true>
676nor C<false> values will be generated.
677 664
678=item $perl_scalar = $json->decode ($json_text) 665=item $perl_scalar = $json->decode ($json_text)
679 666
680The opposite of C<encode>: expects a JSON text and tries to parse it, 667The opposite of C<encode>: expects a JSON text and tries to parse it,
681returning the resulting simple scalar or reference. Croaks on error. 668returning the resulting simple scalar or reference. Croaks on error.
682
683JSON numbers and strings become simple Perl scalars. JSON arrays become
684Perl arrayrefs and JSON objects become Perl hashrefs. C<true> becomes
685C<1>, C<false> becomes C<0> and C<null> becomes C<undef>.
686 669
687=item ($perl_scalar, $characters) = $json->decode_prefix ($json_text) 670=item ($perl_scalar, $characters) = $json->decode_prefix ($json_text)
688 671
689This works like the C<decode> method, but instead of raising an exception 672This works like the C<decode> method, but instead of raising an exception
690when there is trailing garbage after the first JSON object, it will 673when there is trailing garbage after the first JSON object, it will
… …
713calls). 696calls).
714 697
715JSON::XS will only attempt to parse the JSON text once it is sure it 698JSON::XS will only attempt to parse the JSON text once it is sure it
716has enough text to get a decisive result, using a very simple but 699has enough text to get a decisive result, using a very simple but
717truly incremental parser. This means that it sometimes won't stop as 700truly incremental parser. This means that it sometimes won't stop as
718early as the full parser, for example, it doesn't detect parenthese 701early as the full parser, for example, it doesn't detect mismatched
719mismatches. The only thing it guarantees is that it starts decoding as 702parentheses. The only thing it guarantees is that it starts decoding as
720soon as a syntactically valid JSON text has been seen. This means you need 703soon as a syntactically valid JSON text has been seen. This means you need
721to set resource limits (e.g. C<max_size>) to ensure the parser will stop 704to set resource limits (e.g. C<max_size>) to ensure the parser will stop
722parsing in the presence if syntax errors. 705parsing in the presence if syntax errors.
723 706
724The following methods implement this incremental parser. 707The following methods implement this incremental parser.
… …
740 723
741If the method is called in scalar context, then it will try to extract 724If the method is called in scalar context, then it will try to extract
742exactly I<one> JSON object. If that is successful, it will return this 725exactly I<one> JSON object. If that is successful, it will return this
743object, otherwise it will return C<undef>. If there is a parse error, 726object, otherwise it will return C<undef>. If there is a parse error,
744this method will croak just as C<decode> would do (one can then use 727this method will croak just as C<decode> would do (one can then use
745C<incr_skip> to skip the errornous part). This is the most common way of 728C<incr_skip> to skip the erroneous part). This is the most common way of
746using the method. 729using the method.
747 730
748And finally, in list context, it will try to extract as many objects 731And finally, in list context, it will try to extract as many objects
749from the stream as it can find and return them, or the empty list 732from the stream as it can find and return them, or the empty list
750otherwise. For this to work, there must be no separators between the JSON 733otherwise. For this to work, there must be no separators between the JSON
751objects or arrays, instead they must be concatenated back-to-back. If 734objects or arrays, instead they must be concatenated back-to-back. If
752an error occurs, an exception will be raised as in the scalar context 735an error occurs, an exception will be raised as in the scalar context
753case. Note that in this case, any previously-parsed JSON texts will be 736case. Note that in this case, any previously-parsed JSON texts will be
754lost. 737lost.
755 738
739Example: Parse some JSON arrays/objects in a given string and return
740them.
741
742 my @objs = JSON::XS->new->incr_parse ("[5][7][1,2]");
743
756=item $lvalue_string = $json->incr_text 744=item $lvalue_string = $json->incr_text
757 745
758This method returns the currently stored JSON fragment as an lvalue, that 746This method returns the currently stored JSON fragment as an lvalue, that
759is, you can manipulate it. This I<only> works when a preceding call to 747is, you can manipulate it. This I<only> works when a preceding call to
760C<incr_parse> in I<scalar context> successfully returned an object. Under 748C<incr_parse> in I<scalar context> successfully returned an object. Under
… …
774C<incr_parse> died, in which case the input buffer and incremental parser 762C<incr_parse> died, in which case the input buffer and incremental parser
775state is left unchanged, to skip the text parsed so far and to reset the 763state is left unchanged, to skip the text parsed so far and to reset the
776parse state. 764parse state.
777 765
778The difference to C<incr_reset> is that only text until the parse error 766The difference to C<incr_reset> is that only text until the parse error
779occured is removed. 767occurred is removed.
780 768
781=item $json->incr_reset 769=item $json->incr_reset
782 770
783This completely resets the incremental parser, that is, after this call, 771This completely resets the incremental parser, that is, after this call,
784it will be as if the parser had never parsed anything. 772it will be as if the parser had never parsed anything.
… …
982If the number consists of digits only, JSON::XS will try to represent 970If the number consists of digits only, JSON::XS will try to represent
983it as an integer value. If that fails, it will try to represent it as 971it as an integer value. If that fails, it will try to represent it as
984a numeric (floating point) value if that is possible without loss of 972a numeric (floating point) value if that is possible without loss of
985precision. Otherwise it will preserve the number as a string value (in 973precision. Otherwise it will preserve the number as a string value (in
986which case you lose roundtripping ability, as the JSON number will be 974which case you lose roundtripping ability, as the JSON number will be
987re-encoded toa JSON string). 975re-encoded to a JSON string).
988 976
989Numbers containing a fractional or exponential part will always be 977Numbers containing a fractional or exponential part will always be
990represented as numeric (floating point) values, possibly at a loss of 978represented as numeric (floating point) values, possibly at a loss of
991precision (in which case you might lose perfect roundtripping ability, but 979precision (in which case you might lose perfect roundtripping ability, but
992the JSON number will still be re-encoded as a JSON number). 980the JSON number will still be re-encoded as a JSON number).
993 981
982Note that precision is not accuracy - binary floating point values cannot
983represent most decimal fractions exactly, and when converting from and to
984floating point, JSON::XS only guarantees precision up to but not including
985the least significant bit.
986
994=item true, false 987=item true, false
995 988
996These JSON atoms become C<JSON::XS::true> and C<JSON::XS::false>, 989These JSON atoms become C<JSON::XS::true> and C<JSON::XS::false>,
997respectively. They are overloaded to act almost exactly like the numbers 990respectively. They are overloaded to act almost exactly like the numbers
998C<1> and C<0>. You can check whether a scalar is a JSON boolean by using 991C<1> and C<0>. You can check whether a scalar is a JSON boolean by using
… …
1013 1006
1014=over 4 1007=over 4
1015 1008
1016=item hash references 1009=item hash references
1017 1010
1018Perl hash references become JSON objects. As there is no inherent ordering 1011Perl hash references become JSON objects. As there is no inherent
1019in hash keys (or JSON objects), they will usually be encoded in a 1012ordering in hash keys (or JSON objects), they will usually be encoded
1020pseudo-random order that can change between runs of the same program but 1013in a pseudo-random order. JSON::XS can optionally sort the hash keys
1021stays generally the same within a single run of a program. JSON::XS can 1014(determined by the I<canonical> flag), so the same datastructure will
1022optionally sort the hash keys (determined by the I<canonical> flag), so 1015serialise to the same JSON text (given same settings and version of
1023the same datastructure will serialise to the same JSON text (given same 1016JSON::XS), but this incurs a runtime overhead and is only rarely useful,
1024settings and version of JSON::XS), but this incurs a runtime overhead 1017e.g. when you want to compare some JSON text against another for equality.
1025and is only rarely useful, e.g. when you want to compare some JSON text
1026against another for equality.
1027 1018
1028=item array references 1019=item array references
1029 1020
1030Perl array references become JSON arrays. 1021Perl array references become JSON arrays.
1031 1022
… …
1084 $x *= 1; # same thing, the choice is yours. 1075 $x *= 1; # same thing, the choice is yours.
1085 1076
1086You can not currently force the type in other, less obscure, ways. Tell me 1077You can not currently force the type in other, less obscure, ways. Tell me
1087if you need this capability (but don't forget to explain why it's needed 1078if you need this capability (but don't forget to explain why it's needed
1088:). 1079:).
1080
1081Note that numerical precision has the same meaning as under Perl (so
1082binary to decimal conversion follows the same rules as in Perl, which
1083can differ to other languages). Also, your perl interpreter might expose
1084extensions to the floating point numbers of your platform, such as
1085infinities or NaN's - these cannot be represented in JSON, and it is an
1086error to pass those in.
1089 1087
1090=back 1088=back
1091 1089
1092 1090
1093=head1 ENCODING/CODESET FLAG NOTES 1091=head1 ENCODING/CODESET FLAG NOTES
… …
1120=item C<utf8> flag disabled 1118=item C<utf8> flag disabled
1121 1119
1122When C<utf8> is disabled (the default), then C<encode>/C<decode> generate 1120When C<utf8> is disabled (the default), then C<encode>/C<decode> generate
1123and expect Unicode strings, that is, characters with high ordinal Unicode 1121and expect Unicode strings, that is, characters with high ordinal Unicode
1124values (> 255) will be encoded as such characters, and likewise such 1122values (> 255) will be encoded as such characters, and likewise such
1125characters are decoded as-is, no canges to them will be done, except 1123characters are decoded as-is, no changes to them will be done, except
1126"(re-)interpreting" them as Unicode codepoints or Unicode characters, 1124"(re-)interpreting" them as Unicode codepoints or Unicode characters,
1127respectively (to Perl, these are the same thing in strings unless you do 1125respectively (to Perl, these are the same thing in strings unless you do
1128funny/weird/dumb stuff). 1126funny/weird/dumb stuff).
1129 1127
1130This is useful when you want to do the encoding yourself (e.g. when you 1128This is useful when you want to do the encoding yourself (e.g. when you
… …
1238well - using C<eval> naively simply I<will> cause problems. 1236well - using C<eval> naively simply I<will> cause problems.
1239 1237
1240Another problem is that some javascript implementations reserve 1238Another problem is that some javascript implementations reserve
1241some property names for their own purposes (which probably makes 1239some property names for their own purposes (which probably makes
1242them non-ECMAscript-compliant). For example, Iceweasel reserves the 1240them non-ECMAscript-compliant). For example, Iceweasel reserves the
1243C<__proto__> property name for it's own purposes. 1241C<__proto__> property name for its own purposes.
1244 1242
1245If that is a problem, you could parse try to filter the resulting JSON 1243If that is a problem, you could parse try to filter the resulting JSON
1246output for these property strings, e.g.: 1244output for these property strings, e.g.:
1247 1245
1248 $json =~ s/"__proto__"\s*:/"__proto__renamed":/g; 1246 $json =~ s/"__proto__"\s*:/"__proto__renamed":/g;
1249 1247
1250This works because C<__proto__> is not valid outside of strings, so every 1248This works because C<__proto__> is not valid outside of strings, so every
1251occurence of C<"__proto__"\s*:> must be a string used as property name. 1249occurrence of C<"__proto__"\s*:> must be a string used as property name.
1252 1250
1253If you know of other incompatibilities, please let me know. 1251If you know of other incompatibilities, please let me know.
1254 1252
1255 1253
1256=head2 JSON and YAML 1254=head2 JSON and YAML
… …
1302that difficult or long) and finally make YAML compatible to it, and 1300that difficult or long) and finally make YAML compatible to it, and
1303educating users about the changes, instead of spreading lies about the 1301educating users about the changes, instead of spreading lies about the
1304real compatibility for many I<years> and trying to silence people who 1302real compatibility for many I<years> and trying to silence people who
1305point out that it isn't true. 1303point out that it isn't true.
1306 1304
1307Addendum/2009: the YAML 1.2 spec is still incomaptible with JSON, even 1305Addendum/2009: the YAML 1.2 spec is still incompatible with JSON, even
1308though the incompatibilities have been documented (and are known to 1306though the incompatibilities have been documented (and are known to Brian)
1309Brian) for many years and the spec makes explicit claims that YAML is a 1307for many years and the spec makes explicit claims that YAML is a superset
1310superset of JSON. It would be so easy to fix, but apparently, bullying and 1308of JSON. It would be so easy to fix, but apparently, bullying people and
1311corrupting userdata is so much easier. 1309corrupting userdata is so much easier.
1312 1310
1313=back 1311=back
1314 1312
1315 1313
… …
1324a very short single-line JSON string (also available at 1322a very short single-line JSON string (also available at
1325L<http://dist.schmorp.de/misc/json/short.json>). 1323L<http://dist.schmorp.de/misc/json/short.json>).
1326 1324
1327 {"method": "handleMessage", "params": ["user1", 1325 {"method": "handleMessage", "params": ["user1",
1328 "we were just talking"], "id": null, "array":[1,11,234,-5,1e5,1e7, 1326 "we were just talking"], "id": null, "array":[1,11,234,-5,1e5,1e7,
1329 true, false]} 1327 1, 0]}
1330 1328
1331It shows the number of encodes/decodes per second (JSON::XS uses 1329It shows the number of encodes/decodes per second (JSON::XS uses
1332the functional interface, while JSON::XS/2 uses the OO interface 1330the functional interface, while JSON::XS/2 uses the OO interface
1333with pretty-printing and hashkey sorting enabled, JSON::XS/3 enables 1331with pretty-printing and hashkey sorting enabled, JSON::XS/3 enables
1334shrink). Higher is better: 1332shrink. JSON::DWIW/DS uses the deserialise function, while JSON::DWIW::FJ
1333uses the from_json method). Higher is better:
1335 1334
1336 module | encode | decode | 1335 module | encode | decode |
1337 -----------|------------|------------| 1336 --------------|------------|------------|
1338 JSON 1.x | 4990.842 | 4088.813 | 1337 JSON::DWIW/DS | 86302.551 | 102300.098 |
1339 JSON::DWIW | 51653.990 | 71575.154 | 1338 JSON::DWIW/FJ | 86302.551 | 75983.768 |
1340 JSON::PC | 65948.176 | 74631.744 | 1339 JSON::PP | 15827.562 | 6638.658 |
1341 JSON::PP | 8931.652 | 3817.168 | 1340 JSON::Syck | 63358.066 | 47662.545 |
1342 JSON::Syck | 24877.248 | 27776.848 | 1341 JSON::XS | 511500.488 | 511500.488 |
1343 JSON::XS | 388361.481 | 227951.304 | 1342 JSON::XS/2 | 291271.111 | 388361.481 |
1344 JSON::XS/2 | 227951.304 | 218453.333 | 1343 JSON::XS/3 | 361577.931 | 361577.931 |
1345 JSON::XS/3 | 338250.323 | 218453.333 | 1344 Storable | 66788.280 | 265462.278 |
1346 Storable | 16500.016 | 135300.129 |
1347 -----------+------------+------------+ 1345 --------------+------------+------------+
1348 1346
1349That is, JSON::XS is about five times faster than JSON::DWIW on encoding, 1347That is, JSON::XS is almost six times faster than JSON::DWIW on encoding,
1350about three times faster on decoding, and over forty times faster 1348about five times faster on decoding, and over thirty to seventy times
1351than JSON, even with pretty-printing and key sorting. It also compares 1349faster than JSON's pure perl implementation. It also compares favourably
1352favourably to Storable for small amounts of data. 1350to Storable for small amounts of data.
1353 1351
1354Using a longer test string (roughly 18KB, generated from Yahoo! Locals 1352Using a longer test string (roughly 18KB, generated from Yahoo! Locals
1355search API (L<http://dist.schmorp.de/misc/json/long.json>). 1353search API (L<http://dist.schmorp.de/misc/json/long.json>).
1356 1354
1357 module | encode | decode | 1355 module | encode | decode |
1358 -----------|------------|------------| 1356 --------------|------------|------------|
1359 JSON 1.x | 55.260 | 34.971 | 1357 JSON::DWIW/DS | 1647.927 | 2673.916 |
1360 JSON::DWIW | 825.228 | 1082.513 | 1358 JSON::DWIW/FJ | 1630.249 | 2596.128 |
1361 JSON::PC | 3571.444 | 2394.829 |
1362 JSON::PP | 210.987 | 32.574 | 1359 JSON::PP | 400.640 | 62.311 |
1363 JSON::Syck | 552.551 | 787.544 | 1360 JSON::Syck | 1481.040 | 1524.869 |
1364 JSON::XS | 5780.463 | 4854.519 | 1361 JSON::XS | 20661.596 | 9541.183 |
1365 JSON::XS/2 | 3869.998 | 4798.975 | 1362 JSON::XS/2 | 10683.403 | 9416.938 |
1366 JSON::XS/3 | 5862.880 | 4798.975 | 1363 JSON::XS/3 | 20661.596 | 9400.054 |
1367 Storable | 4445.002 | 5235.027 | 1364 Storable | 19765.806 | 10000.725 |
1368 -----------+------------+------------+ 1365 --------------+------------+------------+
1369 1366
1370Again, JSON::XS leads by far (except for Storable which non-surprisingly 1367Again, JSON::XS leads by far (except for Storable which non-surprisingly
1371decodes faster). 1368decodes a bit faster).
1372 1369
1373On large strings containing lots of high Unicode characters, some modules 1370On large strings containing lots of high Unicode characters, some modules
1374(such as JSON::PC) seem to decode faster than JSON::XS, but the result 1371(such as JSON::PC) seem to decode faster than JSON::XS, but the result
1375will be broken due to missing (or wrong) Unicode handling. Others refuse 1372will be broken due to missing (or wrong) Unicode handling. Others refuse
1376to decode or encode properly, so it was impossible to prepare a fair 1373to decode or encode properly, so it was impossible to prepare a fair
… …
1412information you might want to make sure that exceptions thrown by JSON::XS 1409information you might want to make sure that exceptions thrown by JSON::XS
1413will not end up in front of untrusted eyes. 1410will not end up in front of untrusted eyes.
1414 1411
1415If you are using JSON::XS to return packets to consumption 1412If you are using JSON::XS to return packets to consumption
1416by JavaScript scripts in a browser you should have a look at 1413by JavaScript scripts in a browser you should have a look at
1417L<http://jpsykes.com/47/practical-csrf-and-json-security> to see whether 1414L<http://blog.archive.jpsykes.com/47/practical-csrf-and-json-security/> to
1418you are vulnerable to some common attack vectors (which really are browser 1415see whether you are vulnerable to some common attack vectors (which really
1419design bugs, but it is still you who will have to deal with it, as major 1416are browser design bugs, but it is still you who will have to deal with
1420browser developers care only for features, not about getting security 1417it, as major browser developers care only for features, not about getting
1421right). 1418security right).
1422 1419
1423 1420
1424=head1 THREADS 1421=head1 THREADS
1425 1422
1426This module is I<not> guaranteed to be thread safe and there are no 1423This module is I<not> guaranteed to be thread safe and there are no
1427plans to change this until Perl gets thread support (as opposed to the 1424plans to change this until Perl gets thread support (as opposed to the
1428horribly slow so-called "threads" which are simply slow and bloated 1425horribly slow so-called "threads" which are simply slow and bloated
1429process simulations - use fork, it's I<much> faster, cheaper, better). 1426process simulations - use fork, it's I<much> faster, cheaper, better).
1430 1427
1431(It might actually work, but you have been warned). 1428(It might actually work, but you have been warned).
1429
1430
1431=head1 THE PERILS OF SETLOCALE
1432
1433Sometimes people avoid the Perl locale support and directly call the
1434system's setlocale function with C<LC_ALL>.
1435
1436This breaks both perl and modules such as JSON::XS, as stringification of
1437numbers no longer works correctly (e.g. C<$x = 0.1; print "$x"+1> might
1438print C<1>, and JSON::XS might output illegal JSON as JSON::XS relies on
1439perl to stringify numbers).
1440
1441The solution is simple: don't call C<setlocale>, or use it for only those
1442categories you need, such as C<LC_MESSAGES> or C<LC_CTYPE>.
1443
1444If you need C<LC_NUMERIC>, you should enable it only around the code that
1445actually needs it (avoiding stringification of numbers), and restore it
1446afterwards.
1432 1447
1433 1448
1434=head1 BUGS 1449=head1 BUGS
1435 1450
1436While the goal of this module is to be correct, that unfortunately does 1451While the goal of this module is to be correct, that unfortunately does

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines