commit a5db7afd3c8cee79e4a2ef8d66b3745c4a81298c · kokirigla.de/hateno

.gitignore

···

       1
       1
       +
       /target

+923

Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "addr2line"

     

       7
       7
       +
       version = "0.24.2"

     

       8
       8
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       9
       9
       +
       checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"

     

       10
       10
       +
       dependencies = [

     

       11
       11
       +
        "gimli",

     

       12
       12
       +
       ]

     

       13
       13
       +
       

     

       14
       14
       +
       [[package]]

     

       15
       15
       +
       name = "adler2"

     

       16
       16
       +
       version = "2.0.1"

     

       17
       17
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       18
       18
       +
       checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"

     

       19
       19
       +
       

     

       20
       20
       +
       [[package]]

     

       21
       21
       +
       name = "android-tzdata"

     

       22
       22
       +
       version = "0.1.1"

     

       23
       23
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       24
       24
       +
       checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"

     

       25
       25
       +
       

     

       26
       26
       +
       [[package]]

     

       27
       27
       +
       name = "android_system_properties"

     

       28
       28
       +
       version = "0.1.5"

     

       29
       29
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       30
       30
       +
       checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"

     

       31
       31
       +
       dependencies = [

     

       32
       32
       +
        "libc",

     

       33
       33
       +
       ]

     

       34
       34
       +
       

     

       35
       35
       +
       [[package]]

     

       36
       36
       +
       name = "autocfg"

     

       37
       37
       +
       version = "1.5.0"

     

       38
       38
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       39
       39
       +
       checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"

     

       40
       40
       +
       

     

       41
       41
       +
       [[package]]

     

       42
       42
       +
       name = "backtrace"

     

       43
       43
       +
       version = "0.3.75"

     

       44
       44
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       45
       45
       +
       checksum = "6806a6321ec58106fea15becdad98371e28d92ccbc7c8f1b3b6dd724fe8f1002"

     

       46
       46
       +
       dependencies = [

     

       47
       47
       +
        "addr2line",

     

       48
       48
       +
        "cfg-if",

     

       49
       49
       +
        "libc",

     

       50
       50
       +
        "miniz_oxide",

     

       51
       51
       +
        "object",

     

       52
       52
       +
        "rustc-demangle",

     

       53
       53
       +
        "windows-targets",

     

       54
       54
       +
       ]

     

       55
       55
       +
       

     

       56
       56
       +
       [[package]]

     

       57
       57
       +
       name = "backtrace-ext"

     

       58
       58
       +
       version = "0.2.1"

     

       59
       59
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       60
       60
       +
       checksum = "537beee3be4a18fb023b570f80e3ae28003db9167a751266b259926e25539d50"

     

       61
       61
       +
       dependencies = [

     

       62
       62
       +
        "backtrace",

     

       63
       63
       +
       ]

     

       64
       64
       +
       

     

       65
       65
       +
       [[package]]

     

       66
       66
       +
       name = "bumpalo"

     

       67
       67
       +
       version = "3.19.0"

     

       68
       68
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       69
       69
       +
       checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"

     

       70
       70
       +
       

     

       71
       71
       +
       [[package]]

     

       72
       72
       +
       name = "byteorder"

     

       73
       73
       +
       version = "1.5.0"

     

       74
       74
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       75
       75
       +
       checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"

     

       76
       76
       +
       

     

       77
       77
       +
       [[package]]

     

       78
       78
       +
       name = "cc"

     

       79
       79
       +
       version = "1.2.33"

     

       80
       80
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       81
       81
       +
       checksum = "3ee0f8803222ba5a7e2777dd72ca451868909b1ac410621b676adf07280e9b5f"

     

       82
       82
       +
       dependencies = [

     

       83
       83
       +
        "shlex",

     

       84
       84
       +
       ]

     

       85
       85
       +
       

     

       86
       86
       +
       [[package]]

     

       87
       87
       +
       name = "cesu8"

     

       88
       88
       +
       version = "1.1.0"

     

       89
       89
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       90
       90
       +
       checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"

     

       91
       91
       +
       

     

       92
       92
       +
       [[package]]

     

       93
       93
       +
       name = "cfg-if"

     

       94
       94
       +
       version = "1.0.1"

     

       95
       95
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       96
       96
       +
       checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"

     

       97
       97
       +
       

     

       98
       98
       +
       [[package]]

     

       99
       99
       +
       name = "chrono"

     

       100
       100
       +
       version = "0.4.41"

     

       101
       101
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       102
       102
       +
       checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"

     

       103
       103
       +
       dependencies = [

     

       104
       104
       +
        "android-tzdata",

     

       105
       105
       +
        "iana-time-zone",

     

       106
       106
       +
        "js-sys",

     

       107
       107
       +
        "num-traits",

     

       108
       108
       +
        "wasm-bindgen",

     

       109
       109
       +
        "windows-link",

     

       110
       110
       +
       ]

     

       111
       111
       +
       

     

       112
       112
       +
       [[package]]

     

       113
       113
       +
       name = "console"

     

       114
       114
       +
       version = "0.15.11"

     

       115
       115
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       116
       116
       +
       checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"

     

       117
       117
       +
       dependencies = [

     

       118
       118
       +
        "encode_unicode",

     

       119
       119
       +
        "libc",

     

       120
       120
       +
        "once_cell",

     

       121
       121
       +
        "windows-sys",

     

       122
       122
       +
       ]

     

       123
       123
       +
       

     

       124
       124
       +
       [[package]]

     

       125
       125
       +
       name = "core-foundation-sys"

     

       126
       126
       +
       version = "0.8.7"

     

       127
       127
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       128
       128
       +
       checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"

     

       129
       129
       +
       

     

       130
       130
       +
       [[package]]

     

       131
       131
       +
       name = "crc32fast"

     

       132
       132
       +
       version = "1.5.0"

     

       133
       133
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       134
       134
       +
       checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"

     

       135
       135
       +
       dependencies = [

     

       136
       136
       +
        "cfg-if",

     

       137
       137
       +
       ]

     

       138
       138
       +
       

     

       139
       139
       +
       [[package]]

     

       140
       140
       +
       name = "encode_unicode"

     

       141
       141
       +
       version = "1.0.0"

     

       142
       142
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       143
       143
       +
       checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"

     

       144
       144
       +
       

     

       145
       145
       +
       [[package]]

     

       146
       146
       +
       name = "equivalent"

     

       147
       147
       +
       version = "1.0.2"

     

       148
       148
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       149
       149
       +
       checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"

     

       150
       150
       +
       

     

       151
       151
       +
       [[package]]

     

       152
       152
       +
       name = "flate2"

     

       153
       153
       +
       version = "1.1.2"

     

       154
       154
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       155
       155
       +
       checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d"

     

       156
       156
       +
       dependencies = [

     

       157
       157
       +
        "crc32fast",

     

       158
       158
       +
        "miniz_oxide",

     

       159
       159
       +
       ]

     

       160
       160
       +
       

     

       161
       161
       +
       [[package]]

     

       162
       162
       +
       name = "getrandom"

     

       163
       163
       +
       version = "0.2.16"

     

       164
       164
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       165
       165
       +
       checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"

     

       166
       166
       +
       dependencies = [

     

       167
       167
       +
        "cfg-if",

     

       168
       168
       +
        "libc",

     

       169
       169
       +
        "wasi",

     

       170
       170
       +
       ]

     

       171
       171
       +
       

     

       172
       172
       +
       [[package]]

     

       173
       173
       +
       name = "gimli"

     

       174
       174
       +
       version = "0.31.1"

     

       175
       175
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       176
       176
       +
       checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"

     

       177
       177
       +
       

     

       178
       178
       +
       [[package]]

     

       179
       179
       +
       name = "hashbrown"

     

       180
       180
       +
       version = "0.15.5"

     

       181
       181
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       182
       182
       +
       checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"

     

       183
       183
       +
       

     

       184
       184
       +
       [[package]]

     

       185
       185
       +
       name = "hermit-abi"

     

       186
       186
       +
       version = "0.5.2"

     

       187
       187
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       188
       188
       +
       checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"

     

       189
       189
       +
       

     

       190
       190
       +
       [[package]]

     

       191
       191
       +
       name = "iana-time-zone"

     

       192
       192
       +
       version = "0.1.63"

     

       193
       193
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       194
       194
       +
       checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"

     

       195
       195
       +
       dependencies = [

     

       196
       196
       +
        "android_system_properties",

     

       197
       197
       +
        "core-foundation-sys",

     

       198
       198
       +
        "iana-time-zone-haiku",

     

       199
       199
       +
        "js-sys",

     

       200
       200
       +
        "log",

     

       201
       201
       +
        "wasm-bindgen",

     

       202
       202
       +
        "windows-core",

     

       203
       203
       +
       ]

     

       204
       204
       +
       

     

       205
       205
       +
       [[package]]

     

       206
       206
       +
       name = "iana-time-zone-haiku"

     

       207
       207
       +
       version = "0.1.2"

     

       208
       208
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       209
       209
       +
       checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"

     

       210
       210
       +
       dependencies = [

     

       211
       211
       +
        "cc",

     

       212
       212
       +
       ]

     

       213
       213
       +
       

     

       214
       214
       +
       [[package]]

     

       215
       215
       +
       name = "indexmap"

     

       216
       216
       +
       version = "2.10.0"

     

       217
       217
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       218
       218
       +
       checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"

     

       219
       219
       +
       dependencies = [

     

       220
       220
       +
        "equivalent",

     

       221
       221
       +
        "hashbrown",

     

       222
       222
       +
       ]

     

       223
       223
       +
       

     

       224
       224
       +
       [[package]]

     

       225
       225
       +
       name = "insta"

     

       226
       226
       +
       version = "1.43.1"

     

       227
       227
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       228
       228
       +
       checksum = "154934ea70c58054b556dd430b99a98c2a7ff5309ac9891597e339b5c28f4371"

     

       229
       229
       +
       dependencies = [

     

       230
       230
       +
        "console",

     

       231
       231
       +
        "once_cell",

     

       232
       232
       +
        "similar",

     

       233
       233
       +
       ]

     

       234
       234
       +
       

     

       235
       235
       +
       [[package]]

     

       236
       236
       +
       name = "is-terminal"

     

       237
       237
       +
       version = "0.4.16"

     

       238
       238
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       239
       239
       +
       checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"

     

       240
       240
       +
       dependencies = [

     

       241
       241
       +
        "hermit-abi",

     

       242
       242
       +
        "libc",

     

       243
       243
       +
        "windows-sys",

     

       244
       244
       +
       ]

     

       245
       245
       +
       

     

       246
       246
       +
       [[package]]

     

       247
       247
       +
       name = "is_ci"

     

       248
       248
       +
       version = "1.2.0"

     

       249
       249
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       250
       250
       +
       checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45"

     

       251
       251
       +
       

     

       252
       252
       +
       [[package]]

     

       253
       253
       +
       name = "js-sys"

     

       254
       254
       +
       version = "0.3.77"

     

       255
       255
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       256
       256
       +
       checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"

     

       257
       257
       +
       dependencies = [

     

       258
       258
       +
        "once_cell",

     

       259
       259
       +
        "wasm-bindgen",

     

       260
       260
       +
       ]

     

       261
       261
       +
       

     

       262
       262
       +
       [[package]]

     

       263
       263
       +
       name = "libc"

     

       264
       264
       +
       version = "0.2.175"

     

       265
       265
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       266
       266
       +
       checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"

     

       267
       267
       +
       

     

       268
       268
       +
       [[package]]

     

       269
       269
       +
       name = "log"

     

       270
       270
       +
       version = "0.4.27"

     

       271
       271
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       272
       272
       +
       checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"

     

       273
       273
       +
       

     

       274
       274
       +
       [[package]]

     

       275
       275
       +
       name = "lz4"

     

       276
       276
       +
       version = "1.28.1"

     

       277
       277
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       278
       278
       +
       checksum = "a20b523e860d03443e98350ceaac5e71c6ba89aea7d960769ec3ce37f4de5af4"

     

       279
       279
       +
       dependencies = [

     

       280
       280
       +
        "lz4-sys",

     

       281
       281
       +
       ]

     

       282
       282
       +
       

     

       283
       283
       +
       [[package]]

     

       284
       284
       +
       name = "lz4-sys"

     

       285
       285
       +
       version = "1.11.1+lz4-1.10.0"

     

       286
       286
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       287
       287
       +
       checksum = "6bd8c0d6c6ed0cd30b3652886bb8711dc4bb01d637a68105a3d5158039b418e6"

     

       288
       288
       +
       dependencies = [

     

       289
       289
       +
        "cc",

     

       290
       290
       +
        "libc",

     

       291
       291
       +
       ]

     

       292
       292
       +
       

     

       293
       293
       +
       [[package]]

     

       294
       294
       +
       name = "memchr"

     

       295
       295
       +
       version = "2.7.5"

     

       296
       296
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       297
       297
       +
       checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"

     

       298
       298
       +
       

     

       299
       299
       +
       [[package]]

     

       300
       300
       +
       name = "miette"

     

       301
       301
       +
       version = "5.10.0"

     

       302
       302
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       303
       303
       +
       checksum = "59bb584eaeeab6bd0226ccf3509a69d7936d148cf3d036ad350abe35e8c6856e"

     

       304
       304
       +
       dependencies = [

     

       305
       305
       +
        "backtrace",

     

       306
       306
       +
        "backtrace-ext",

     

       307
       307
       +
        "is-terminal",

     

       308
       308
       +
        "miette-derive",

     

       309
       309
       +
        "once_cell",

     

       310
       310
       +
        "owo-colors",

     

       311
       311
       +
        "supports-color",

     

       312
       312
       +
        "supports-hyperlinks",

     

       313
       313
       +
        "supports-unicode",

     

       314
       314
       +
        "terminal_size",

     

       315
       315
       +
        "textwrap",

     

       316
       316
       +
        "thiserror 1.0.69",

     

       317
       317
       +
        "unicode-width",

     

       318
       318
       +
       ]

     

       319
       319
       +
       

     

       320
       320
       +
       [[package]]

     

       321
       321
       +
       name = "miette-derive"

     

       322
       322
       +
       version = "5.10.0"

     

       323
       323
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       324
       324
       +
       checksum = "49e7bc1560b95a3c4a25d03de42fe76ca718ab92d1a22a55b9b4cf67b3ae635c"

     

       325
       325
       +
       dependencies = [

     

       326
       326
       +
        "proc-macro2",

     

       327
       327
       +
        "quote",

     

       328
       328
       +
        "syn",

     

       329
       329
       +
       ]

     

       330
       330
       +
       

     

       331
       331
       +
       [[package]]

     

       332
       332
       +
       name = "miniz_oxide"

     

       333
       333
       +
       version = "0.8.9"

     

       334
       334
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       335
       335
       +
       checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"

     

       336
       336
       +
       dependencies = [

     

       337
       337
       +
        "adler2",

     

       338
       338
       +
       ]

     

       339
       339
       +
       

     

       340
       340
       +
       [[package]]

     

       341
       341
       +
       name = "nbt2"

     

       342
       342
       +
       version = "0.1.0"

     

       343
       343
       +
       dependencies = [

     

       344
       344
       +
        "chrono",

     

       345
       345
       +
        "flate2",

     

       346
       346
       +
        "insta",

     

       347
       347
       +
        "lz4",

     

       348
       348
       +
        "thiserror 2.0.15",

     

       349
       349
       +
        "uuid",

     

       350
       350
       +
       ]

     

       351
       351
       +
       

     

       352
       352
       +
       [[package]]

     

       353
       353
       +
       name = "nbt2_migrate"

     

       354
       354
       +
       version = "0.1.0"

     

       355
       355
       +
       dependencies = [

     

       356
       356
       +
        "insta",

     

       357
       357
       +
        "nbt2",

     

       358
       358
       +
        "nbtree_core",

     

       359
       359
       +
        "thiserror 2.0.15",

     

       360
       360
       +
        "uuid",

     

       361
       361
       +
       ]

     

       362
       362
       +
       

     

       363
       363
       +
       [[package]]

     

       364
       364
       +
       name = "nbtree_core"

     

       365
       365
       +
       version = "0.1.0"

     

       366
       366
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       367
       367
       +
       checksum = "8b997801ac5ce31a845d736bfe838113079c3e56cff1ed498813e793c6c6959c"

     

       368
       368
       +
       dependencies = [

     

       369
       369
       +
        "byteorder",

     

       370
       370
       +
        "cesu8",

     

       371
       371
       +
        "indexmap",

     

       372
       372
       +
        "miette",

     

       373
       373
       +
        "num-traits",

     

       374
       374
       +
        "thiserror 2.0.15",

     

       375
       375
       +
        "unicode_names2",

     

       376
       376
       +
       ]

     

       377
       377
       +
       

     

       378
       378
       +
       [[package]]

     

       379
       379
       +
       name = "num-traits"

     

       380
       380
       +
       version = "0.2.19"

     

       381
       381
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       382
       382
       +
       checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"

     

       383
       383
       +
       dependencies = [

     

       384
       384
       +
        "autocfg",

     

       385
       385
       +
       ]

     

       386
       386
       +
       

     

       387
       387
       +
       [[package]]

     

       388
       388
       +
       name = "object"

     

       389
       389
       +
       version = "0.36.7"

     

       390
       390
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       391
       391
       +
       checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"

     

       392
       392
       +
       dependencies = [

     

       393
       393
       +
        "memchr",

     

       394
       394
       +
       ]

     

       395
       395
       +
       

     

       396
       396
       +
       [[package]]

     

       397
       397
       +
       name = "once_cell"

     

       398
       398
       +
       version = "1.21.3"

     

       399
       399
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       400
       400
       +
       checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"

     

       401
       401
       +
       

     

       402
       402
       +
       [[package]]

     

       403
       403
       +
       name = "owo-colors"

     

       404
       404
       +
       version = "3.5.0"

     

       405
       405
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       406
       406
       +
       checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f"

     

       407
       407
       +
       

     

       408
       408
       +
       [[package]]

     

       409
       409
       +
       name = "phf"

     

       410
       410
       +
       version = "0.11.3"

     

       411
       411
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       412
       412
       +
       checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"

     

       413
       413
       +
       dependencies = [

     

       414
       414
       +
        "phf_shared",

     

       415
       415
       +
       ]

     

       416
       416
       +
       

     

       417
       417
       +
       [[package]]

     

       418
       418
       +
       name = "phf_codegen"

     

       419
       419
       +
       version = "0.11.3"

     

       420
       420
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       421
       421
       +
       checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"

     

       422
       422
       +
       dependencies = [

     

       423
       423
       +
        "phf_generator",

     

       424
       424
       +
        "phf_shared",

     

       425
       425
       +
       ]

     

       426
       426
       +
       

     

       427
       427
       +
       [[package]]

     

       428
       428
       +
       name = "phf_generator"

     

       429
       429
       +
       version = "0.11.3"

     

       430
       430
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       431
       431
       +
       checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"

     

       432
       432
       +
       dependencies = [

     

       433
       433
       +
        "phf_shared",

     

       434
       434
       +
        "rand",

     

       435
       435
       +
       ]

     

       436
       436
       +
       

     

       437
       437
       +
       [[package]]

     

       438
       438
       +
       name = "phf_shared"

     

       439
       439
       +
       version = "0.11.3"

     

       440
       440
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       441
       441
       +
       checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"

     

       442
       442
       +
       dependencies = [

     

       443
       443
       +
        "siphasher",

     

       444
       444
       +
       ]

     

       445
       445
       +
       

     

       446
       446
       +
       [[package]]

     

       447
       447
       +
       name = "ppv-lite86"

     

       448
       448
       +
       version = "0.2.21"

     

       449
       449
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       450
       450
       +
       checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"

     

       451
       451
       +
       dependencies = [

     

       452
       452
       +
        "zerocopy",

     

       453
       453
       +
       ]

     

       454
       454
       +
       

     

       455
       455
       +
       [[package]]

     

       456
       456
       +
       name = "proc-macro2"

     

       457
       457
       +
       version = "1.0.101"

     

       458
       458
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       459
       459
       +
       checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"

     

       460
       460
       +
       dependencies = [

     

       461
       461
       +
        "unicode-ident",

     

       462
       462
       +
       ]

     

       463
       463
       +
       

     

       464
       464
       +
       [[package]]

     

       465
       465
       +
       name = "quote"

     

       466
       466
       +
       version = "1.0.40"

     

       467
       467
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       468
       468
       +
       checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"

     

       469
       469
       +
       dependencies = [

     

       470
       470
       +
        "proc-macro2",

     

       471
       471
       +
       ]

     

       472
       472
       +
       

     

       473
       473
       +
       [[package]]

     

       474
       474
       +
       name = "rand"

     

       475
       475
       +
       version = "0.8.5"

     

       476
       476
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       477
       477
       +
       checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"

     

       478
       478
       +
       dependencies = [

     

       479
       479
       +
        "libc",

     

       480
       480
       +
        "rand_chacha",

     

       481
       481
       +
        "rand_core",

     

       482
       482
       +
       ]

     

       483
       483
       +
       

     

       484
       484
       +
       [[package]]

     

       485
       485
       +
       name = "rand_chacha"

     

       486
       486
       +
       version = "0.3.1"

     

       487
       487
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       488
       488
       +
       checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"

     

       489
       489
       +
       dependencies = [

     

       490
       490
       +
        "ppv-lite86",

     

       491
       491
       +
        "rand_core",

     

       492
       492
       +
       ]

     

       493
       493
       +
       

     

       494
       494
       +
       [[package]]

     

       495
       495
       +
       name = "rand_core"

     

       496
       496
       +
       version = "0.6.4"

     

       497
       497
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       498
       498
       +
       checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"

     

       499
       499
       +
       dependencies = [

     

       500
       500
       +
        "getrandom",

     

       501
       501
       +
       ]

     

       502
       502
       +
       

     

       503
       503
       +
       [[package]]

     

       504
       504
       +
       name = "rustc-demangle"

     

       505
       505
       +
       version = "0.1.26"

     

       506
       506
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       507
       507
       +
       checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"

     

       508
       508
       +
       

     

       509
       509
       +
       [[package]]

     

       510
       510
       +
       name = "rustversion"

     

       511
       511
       +
       version = "1.0.22"

     

       512
       512
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       513
       513
       +
       checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"

     

       514
       514
       +
       

     

       515
       515
       +
       [[package]]

     

       516
       516
       +
       name = "shlex"

     

       517
       517
       +
       version = "1.3.0"

     

       518
       518
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       519
       519
       +
       checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"

     

       520
       520
       +
       

     

       521
       521
       +
       [[package]]

     

       522
       522
       +
       name = "similar"

     

       523
       523
       +
       version = "2.7.0"

     

       524
       524
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       525
       525
       +
       checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"

     

       526
       526
       +
       

     

       527
       527
       +
       [[package]]

     

       528
       528
       +
       name = "siphasher"

     

       529
       529
       +
       version = "1.0.1"

     

       530
       530
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       531
       531
       +
       checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"

     

       532
       532
       +
       

     

       533
       533
       +
       [[package]]

     

       534
       534
       +
       name = "smawk"

     

       535
       535
       +
       version = "0.3.2"

     

       536
       536
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       537
       537
       +
       checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"

     

       538
       538
       +
       

     

       539
       539
       +
       [[package]]

     

       540
       540
       +
       name = "supports-color"

     

       541
       541
       +
       version = "2.1.0"

     

       542
       542
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       543
       543
       +
       checksum = "d6398cde53adc3c4557306a96ce67b302968513830a77a95b2b17305d9719a89"

     

       544
       544
       +
       dependencies = [

     

       545
       545
       +
        "is-terminal",

     

       546
       546
       +
        "is_ci",

     

       547
       547
       +
       ]

     

       548
       548
       +
       

     

       549
       549
       +
       [[package]]

     

       550
       550
       +
       name = "supports-hyperlinks"

     

       551
       551
       +
       version = "2.1.0"

     

       552
       552
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       553
       553
       +
       checksum = "f84231692eb0d4d41e4cdd0cabfdd2e6cd9e255e65f80c9aa7c98dd502b4233d"

     

       554
       554
       +
       dependencies = [

     

       555
       555
       +
        "is-terminal",

     

       556
       556
       +
       ]

     

       557
       557
       +
       

     

       558
       558
       +
       [[package]]

     

       559
       559
       +
       name = "supports-unicode"

     

       560
       560
       +
       version = "2.1.0"

     

       561
       561
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       562
       562
       +
       checksum = "f850c19edd184a205e883199a261ed44471c81e39bd95b1357f5febbef00e77a"

     

       563
       563
       +
       dependencies = [

     

       564
       564
       +
        "is-terminal",

     

       565
       565
       +
       ]

     

       566
       566
       +
       

     

       567
       567
       +
       [[package]]

     

       568
       568
       +
       name = "syn"

     

       569
       569
       +
       version = "2.0.106"

     

       570
       570
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       571
       571
       +
       checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"

     

       572
       572
       +
       dependencies = [

     

       573
       573
       +
        "proc-macro2",

     

       574
       574
       +
        "quote",

     

       575
       575
       +
        "unicode-ident",

     

       576
       576
       +
       ]

     

       577
       577
       +
       

     

       578
       578
       +
       [[package]]

     

       579
       579
       +
       name = "terminal_size"

     

       580
       580
       +
       version = "0.1.17"

     

       581
       581
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       582
       582
       +
       checksum = "633c1a546cee861a1a6d0dc69ebeca693bf4296661ba7852b9d21d159e0506df"

     

       583
       583
       +
       dependencies = [

     

       584
       584
       +
        "libc",

     

       585
       585
       +
        "winapi",

     

       586
       586
       +
       ]

     

       587
       587
       +
       

     

       588
       588
       +
       [[package]]

     

       589
       589
       +
       name = "textwrap"

     

       590
       590
       +
       version = "0.15.2"

     

       591
       591
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       592
       592
       +
       checksum = "b7b3e525a49ec206798b40326a44121291b530c963cfb01018f63e135bac543d"

     

       593
       593
       +
       dependencies = [

     

       594
       594
       +
        "smawk",

     

       595
       595
       +
        "unicode-linebreak",

     

       596
       596
       +
        "unicode-width",

     

       597
       597
       +
       ]

     

       598
       598
       +
       

     

       599
       599
       +
       [[package]]

     

       600
       600
       +
       name = "thiserror"

     

       601
       601
       +
       version = "1.0.69"

     

       602
       602
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       603
       603
       +
       checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"

     

       604
       604
       +
       dependencies = [

     

       605
       605
       +
        "thiserror-impl 1.0.69",

     

       606
       606
       +
       ]

     

       607
       607
       +
       

     

       608
       608
       +
       [[package]]

     

       609
       609
       +
       name = "thiserror"

     

       610
       610
       +
       version = "2.0.15"

     

       611
       611
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       612
       612
       +
       checksum = "80d76d3f064b981389ecb4b6b7f45a0bf9fdac1d5b9204c7bd6714fecc302850"

     

       613
       613
       +
       dependencies = [

     

       614
       614
       +
        "thiserror-impl 2.0.15",

     

       615
       615
       +
       ]

     

       616
       616
       +
       

     

       617
       617
       +
       [[package]]

     

       618
       618
       +
       name = "thiserror-impl"

     

       619
       619
       +
       version = "1.0.69"

     

       620
       620
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       621
       621
       +
       checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"

     

       622
       622
       +
       dependencies = [

     

       623
       623
       +
        "proc-macro2",

     

       624
       624
       +
        "quote",

     

       625
       625
       +
        "syn",

     

       626
       626
       +
       ]

     

       627
       627
       +
       

     

       628
       628
       +
       [[package]]

     

       629
       629
       +
       name = "thiserror-impl"

     

       630
       630
       +
       version = "2.0.15"

     

       631
       631
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       632
       632
       +
       checksum = "44d29feb33e986b6ea906bd9c3559a856983f92371b3eaa5e83782a351623de0"

     

       633
       633
       +
       dependencies = [

     

       634
       634
       +
        "proc-macro2",

     

       635
       635
       +
        "quote",

     

       636
       636
       +
        "syn",

     

       637
       637
       +
       ]

     

       638
       638
       +
       

     

       639
       639
       +
       [[package]]

     

       640
       640
       +
       name = "unicode-ident"

     

       641
       641
       +
       version = "1.0.18"

     

       642
       642
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       643
       643
       +
       checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"

     

       644
       644
       +
       

     

       645
       645
       +
       [[package]]

     

       646
       646
       +
       name = "unicode-linebreak"

     

       647
       647
       +
       version = "0.1.5"

     

       648
       648
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       649
       649
       +
       checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"

     

       650
       650
       +
       

     

       651
       651
       +
       [[package]]

     

       652
       652
       +
       name = "unicode-width"

     

       653
       653
       +
       version = "0.1.14"

     

       654
       654
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       655
       655
       +
       checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"

     

       656
       656
       +
       

     

       657
       657
       +
       [[package]]

     

       658
       658
       +
       name = "unicode_names2"

     

       659
       659
       +
       version = "2.0.0"

     

       660
       660
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       661
       661
       +
       checksum = "d189085656ca1203291e965444e7f6a2723fbdd1dd9f34f8482e79bafd8338a0"

     

       662
       662
       +
       dependencies = [

     

       663
       663
       +
        "phf",

     

       664
       664
       +
        "unicode_names2_generator",

     

       665
       665
       +
       ]

     

       666
       666
       +
       

     

       667
       667
       +
       [[package]]

     

       668
       668
       +
       name = "unicode_names2_generator"

     

       669
       669
       +
       version = "2.0.0"

     

       670
       670
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       671
       671
       +
       checksum = "1262662dc96937c71115228ce2e1d30f41db71a7a45d3459e98783ef94052214"

     

       672
       672
       +
       dependencies = [

     

       673
       673
       +
        "phf_codegen",

     

       674
       674
       +
        "rand",

     

       675
       675
       +
       ]

     

       676
       676
       +
       

     

       677
       677
       +
       [[package]]

     

       678
       678
       +
       name = "uuid"

     

       679
       679
       +
       version = "1.18.0"

     

       680
       680
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       681
       681
       +
       checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be"

     

       682
       682
       +
       dependencies = [

     

       683
       683
       +
        "js-sys",

     

       684
       684
       +
        "wasm-bindgen",

     

       685
       685
       +
       ]

     

       686
       686
       +
       

     

       687
       687
       +
       [[package]]

     

       688
       688
       +
       name = "wasi"

     

       689
       689
       +
       version = "0.11.1+wasi-snapshot-preview1"

     

       690
       690
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       691
       691
       +
       checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"

     

       692
       692
       +
       

     

       693
       693
       +
       [[package]]

     

       694
       694
       +
       name = "wasm-bindgen"

     

       695
       695
       +
       version = "0.2.100"

     

       696
       696
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       697
       697
       +
       checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"

     

       698
       698
       +
       dependencies = [

     

       699
       699
       +
        "cfg-if",

     

       700
       700
       +
        "once_cell",

     

       701
       701
       +
        "rustversion",

     

       702
       702
       +
        "wasm-bindgen-macro",

     

       703
       703
       +
       ]

     

       704
       704
       +
       

     

       705
       705
       +
       [[package]]

     

       706
       706
       +
       name = "wasm-bindgen-backend"

     

       707
       707
       +
       version = "0.2.100"

     

       708
       708
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       709
       709
       +
       checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"

     

       710
       710
       +
       dependencies = [

     

       711
       711
       +
        "bumpalo",

     

       712
       712
       +
        "log",

     

       713
       713
       +
        "proc-macro2",

     

       714
       714
       +
        "quote",

     

       715
       715
       +
        "syn",

     

       716
       716
       +
        "wasm-bindgen-shared",

     

       717
       717
       +
       ]

     

       718
       718
       +
       

     

       719
       719
       +
       [[package]]

     

       720
       720
       +
       name = "wasm-bindgen-macro"

     

       721
       721
       +
       version = "0.2.100"

     

       722
       722
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       723
       723
       +
       checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"

     

       724
       724
       +
       dependencies = [

     

       725
       725
       +
        "quote",

     

       726
       726
       +
        "wasm-bindgen-macro-support",

     

       727
       727
       +
       ]

     

       728
       728
       +
       

     

       729
       729
       +
       [[package]]

     

       730
       730
       +
       name = "wasm-bindgen-macro-support"

     

       731
       731
       +
       version = "0.2.100"

     

       732
       732
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       733
       733
       +
       checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"

     

       734
       734
       +
       dependencies = [

     

       735
       735
       +
        "proc-macro2",

     

       736
       736
       +
        "quote",

     

       737
       737
       +
        "syn",

     

       738
       738
       +
        "wasm-bindgen-backend",

     

       739
       739
       +
        "wasm-bindgen-shared",

     

       740
       740
       +
       ]

     

       741
       741
       +
       

     

       742
       742
       +
       [[package]]

     

       743
       743
       +
       name = "wasm-bindgen-shared"

     

       744
       744
       +
       version = "0.2.100"

     

       745
       745
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       746
       746
       +
       checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"

     

       747
       747
       +
       dependencies = [

     

       748
       748
       +
        "unicode-ident",

     

       749
       749
       +
       ]

     

       750
       750
       +
       

     

       751
       751
       +
       [[package]]

     

       752
       752
       +
       name = "winapi"

     

       753
       753
       +
       version = "0.3.9"

     

       754
       754
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       755
       755
       +
       checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"

     

       756
       756
       +
       dependencies = [

     

       757
       757
       +
        "winapi-i686-pc-windows-gnu",

     

       758
       758
       +
        "winapi-x86_64-pc-windows-gnu",

     

       759
       759
       +
       ]

     

       760
       760
       +
       

     

       761
       761
       +
       [[package]]

     

       762
       762
       +
       name = "winapi-i686-pc-windows-gnu"

     

       763
       763
       +
       version = "0.4.0"

     

       764
       764
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       765
       765
       +
       checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

     

       766
       766
       +
       

     

       767
       767
       +
       [[package]]

     

       768
       768
       +
       name = "winapi-x86_64-pc-windows-gnu"

     

       769
       769
       +
       version = "0.4.0"

     

       770
       770
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       771
       771
       +
       checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

     

       772
       772
       +
       

     

       773
       773
       +
       [[package]]

     

       774
       774
       +
       name = "windows-core"

     

       775
       775
       +
       version = "0.61.2"

     

       776
       776
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       777
       777
       +
       checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"

     

       778
       778
       +
       dependencies = [

     

       779
       779
       +
        "windows-implement",

     

       780
       780
       +
        "windows-interface",

     

       781
       781
       +
        "windows-link",

     

       782
       782
       +
        "windows-result",

     

       783
       783
       +
        "windows-strings",

     

       784
       784
       +
       ]

     

       785
       785
       +
       

     

       786
       786
       +
       [[package]]

     

       787
       787
       +
       name = "windows-implement"

     

       788
       788
       +
       version = "0.60.0"

     

       789
       789
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       790
       790
       +
       checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"

     

       791
       791
       +
       dependencies = [

     

       792
       792
       +
        "proc-macro2",

     

       793
       793
       +
        "quote",

     

       794
       794
       +
        "syn",

     

       795
       795
       +
       ]

     

       796
       796
       +
       

     

       797
       797
       +
       [[package]]

     

       798
       798
       +
       name = "windows-interface"

     

       799
       799
       +
       version = "0.59.1"

     

       800
       800
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       801
       801
       +
       checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"

     

       802
       802
       +
       dependencies = [

     

       803
       803
       +
        "proc-macro2",

     

       804
       804
       +
        "quote",

     

       805
       805
       +
        "syn",

     

       806
       806
       +
       ]

     

       807
       807
       +
       

     

       808
       808
       +
       [[package]]

     

       809
       809
       +
       name = "windows-link"

     

       810
       810
       +
       version = "0.1.3"

     

       811
       811
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       812
       812
       +
       checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"

     

       813
       813
       +
       

     

       814
       814
       +
       [[package]]

     

       815
       815
       +
       name = "windows-result"

     

       816
       816
       +
       version = "0.3.4"

     

       817
       817
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       818
       818
       +
       checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"

     

       819
       819
       +
       dependencies = [

     

       820
       820
       +
        "windows-link",

     

       821
       821
       +
       ]

     

       822
       822
       +
       

     

       823
       823
       +
       [[package]]

     

       824
       824
       +
       name = "windows-strings"

     

       825
       825
       +
       version = "0.4.2"

     

       826
       826
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       827
       827
       +
       checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"

     

       828
       828
       +
       dependencies = [

     

       829
       829
       +
        "windows-link",

     

       830
       830
       +
       ]

     

       831
       831
       +
       

     

       832
       832
       +
       [[package]]

     

       833
       833
       +
       name = "windows-sys"

     

       834
       834
       +
       version = "0.59.0"

     

       835
       835
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       836
       836
       +
       checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"

     

       837
       837
       +
       dependencies = [

     

       838
       838
       +
        "windows-targets",

     

       839
       839
       +
       ]

     

       840
       840
       +
       

     

       841
       841
       +
       [[package]]

     

       842
       842
       +
       name = "windows-targets"

     

       843
       843
       +
       version = "0.52.6"

     

       844
       844
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       845
       845
       +
       checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"

     

       846
       846
       +
       dependencies = [

     

       847
       847
       +
        "windows_aarch64_gnullvm",

     

       848
       848
       +
        "windows_aarch64_msvc",

     

       849
       849
       +
        "windows_i686_gnu",

     

       850
       850
       +
        "windows_i686_gnullvm",

     

       851
       851
       +
        "windows_i686_msvc",

     

       852
       852
       +
        "windows_x86_64_gnu",

     

       853
       853
       +
        "windows_x86_64_gnullvm",

     

       854
       854
       +
        "windows_x86_64_msvc",

     

       855
       855
       +
       ]

     

       856
       856
       +
       

     

       857
       857
       +
       [[package]]

     

       858
       858
       +
       name = "windows_aarch64_gnullvm"

     

       859
       859
       +
       version = "0.52.6"

     

       860
       860
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       861
       861
       +
       checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"

     

       862
       862
       +
       

     

       863
       863
       +
       [[package]]

     

       864
       864
       +
       name = "windows_aarch64_msvc"

     

       865
       865
       +
       version = "0.52.6"

     

       866
       866
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       867
       867
       +
       checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"

     

       868
       868
       +
       

     

       869
       869
       +
       [[package]]

     

       870
       870
       +
       name = "windows_i686_gnu"

     

       871
       871
       +
       version = "0.52.6"

     

       872
       872
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       873
       873
       +
       checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"

     

       874
       874
       +
       

     

       875
       875
       +
       [[package]]

     

       876
       876
       +
       name = "windows_i686_gnullvm"

     

       877
       877
       +
       version = "0.52.6"

     

       878
       878
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       879
       879
       +
       checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"

     

       880
       880
       +
       

     

       881
       881
       +
       [[package]]

     

       882
       882
       +
       name = "windows_i686_msvc"

     

       883
       883
       +
       version = "0.52.6"

     

       884
       884
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       885
       885
       +
       checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"

     

       886
       886
       +
       

     

       887
       887
       +
       [[package]]

     

       888
       888
       +
       name = "windows_x86_64_gnu"

     

       889
       889
       +
       version = "0.52.6"

     

       890
       890
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       891
       891
       +
       checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"

     

       892
       892
       +
       

     

       893
       893
       +
       [[package]]

     

       894
       894
       +
       name = "windows_x86_64_gnullvm"

     

       895
       895
       +
       version = "0.52.6"

     

       896
       896
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       897
       897
       +
       checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"

     

       898
       898
       +
       

     

       899
       899
       +
       [[package]]

     

       900
       900
       +
       name = "windows_x86_64_msvc"

     

       901
       901
       +
       version = "0.52.6"

     

       902
       902
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       903
       903
       +
       checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"

     

       904
       904
       +
       

     

       905
       905
       +
       [[package]]

     

       906
       906
       +
       name = "zerocopy"

     

       907
       907
       +
       version = "0.8.26"

     

       908
       908
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       909
       909
       +
       checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"

     

       910
       910
       +
       dependencies = [

     

       911
       911
       +
        "zerocopy-derive",

     

       912
       912
       +
       ]

     

       913
       913
       +
       

     

       914
       914
       +
       [[package]]

     

       915
       915
       +
       name = "zerocopy-derive"

     

       916
       916
       +
       version = "0.8.26"

     

       917
       917
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       918
       918
       +
       checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"

     

       919
       919
       +
       dependencies = [

     

       920
       920
       +
        "proc-macro2",

     

       921
       921
       +
        "quote",

     

       922
       922
       +
        "syn",

     

       923
       923
       +
       ]

+42

Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "nbt2"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       license = "MIT OR Apache-2.0"

     

       6
       6
       +
       rust-version = "1.89"

     

       7
       7
       +
       description = "A spiritual successor to the NBT file format created by Mojang."

     

       8
       8
       +
       

     

       9
       9
       +
       [workspace]

     

       10
       10
       +
       members = ["crates/*"]

     

       11
       11
       +
       resolver = "3"

     

       12
       12
       +
       

     

       13
       13
       +
       [dependencies]

     

       14
       14
       +
       chrono.workspace = true

     

       15
       15
       +
       flate2 = { workspace = true, optional = true }

     

       16
       16
       +
       lz4 = { workspace = true, optional = true }

     

       17
       17
       +
       thiserror.workspace = true

     

       18
       18
       +
       uuid.workspace = true

     

       19
       19
       +
       

     

       20
       20
       +
       [workspace.dependencies]

     

       21
       21
       +
       chrono = "0.4"

     

       22
       22
       +
       flate2 = "1.1"

     

       23
       23
       +
       insta = "1.43"

     

       24
       24
       +
       lz4 = "1.28"

     

       25
       25
       +
       nbtree_core = "0.1"

     

       26
       26
       +
       thiserror = "2"

     

       27
       27
       +
       uuid = "1.18"

     

       28
       28
       +
       

     

       29
       29
       +
       [dev-dependencies]

     

       30
       30
       +
       insta.workspace = true

     

       31
       31
       +
       

     

       32
       32
       +
       [features]

     

       33
       33
       +
       default = ["gzip", "lz4"]

     

       34
       34
       +
       gzip = ["dep:flate2"]

     

       35
       35
       +
       zlib = ["gzip"]

     

       36
       36
       +
       lz4 = ["dep:lz4"]

     

       37
       37
       +
       

     

       38
       38
       +
       [lints]

     

       39
       39
       +
       workspace = true

     

       40
       40
       +
       

     

       41
       41
       +
       [workspace.lints.rust]

     

       42
       42
       +
       unsafe_code = "forbid"

+53

Justfile

···

       1
       1
       +
       FEATURES := "--all-features"

     

       2
       2
       +
       NO_DEFAULTS := "--no-default-features"

     

       3
       3
       +
       TARGETS := "--all-targets"

     

       4
       4
       +
       NO_DEPS := "--no-deps"

     

       5
       5
       +
       

     

       6
       6
       +
       alias d := doc

     

       7
       7
       +
       alias do := doc-open

     

       8
       8
       +
       alias l := lint

     

       9
       9
       +
       alias ok := ci

     

       10
       10
       +
       alias t := test

     

       11
       11
       +
       alias un := udeps

     

       12
       12
       +
       

     

       13
       13
       +
       default:

     

       14
       14
       +
           @just -l

     

       15
       15
       +
       

     

       16
       16
       +
       # Tests and lints.

     

       17
       17
       +
       ci: lint test

     

       18
       18
       +
       

     

       19
       19
       +
       # Clean build artifacts.

     

       20
       20
       +
       clean:

     

       21
       21
       +
           cargo clean

     

       22
       22
       +
       

     

       23
       23
       +
       # Generates documentation.

     

       24
       24
       +
       doc:

     

       25
       25
       +
           cargo doc {{ NO_DEPS }}

     

       26
       26
       +
       

     

       27
       27
       +
       # Generates documentation and opens it.

     

       28
       28
       +
       doc-open:

     

       29
       29
       +
           cargo doc {{ NO_DEPS }} --open

     

       30
       30
       +
       

     

       31
       31
       +
       # Check formatting and run clippy on all targets with all features.

     

       32
       32
       +
       lint: check

     

       33
       33
       +
           cargo fmt --all -- --check

     

       34
       34
       +
           cargo clippy {{ FEATURES }} -- -D warnings

     

       35
       35
       +
       

     

       36
       36
       +
       # Format and fix clippy on all targets with all features

     

       37
       37
       +
       lintmut:

     

       38
       38
       +
           cargo fmt --all

     

       39
       39
       +
           cargo clippy {{ FEATURES }} --fix

     

       40
       40
       +
       

     

       41
       41
       +
       # Run all tests, or just one module.

     

       42
       42
       +
       test:

     

       43
       43
       +
           cargo test --doc && \

     

       44
       44
       +
           cargo nextest r {{ FEATURES }} --no-tests pass --workspace --no-fail-fast; \

     

       45
       45
       +
       

     

       46
       46
       +
       # Runs `cargo-udeps` on all targets.

     

       47
       47
       +
       udeps:

     

       48
       48
       +
           cargo +nightly udeps {{ TARGETS }}

     

       49
       49
       +
       

     

       50
       50
       +
       # Runs `cargo check`.

     

       51
       51
       +
       check:

     

       52
       52
       +
           cargo check {{ NO_DEFAULTS }}

     

       53
       53
       +
           cargo check

+422

SPECIFICATION.md

···

       1
       1
       +
       # NBT2 Specification

     

       2
       2
       +
       

     

       3
       3
       +
       The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD",

     

       4
       4
       +
       "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be

     

       5
       5
       +
       interpreted as described in [RFC 2119][rfc2119].

     

       6
       6
       +
       

     

       7
       7
       +
       ## 0. Table of Contents

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- TOC start (generated with https://github.com/derlin/bitdowntoc) -->

     

       10
       10
       +
       

     

       11
       11
       +
       - [1. Overview](#1-overview)

     

       12
       12
       +
           - [1.1 Key Changes](#11-key-changes)

     

       13
       13
       +
       - [2. Data Representation](#2-data-representation)

     

       14
       14
       +
           - [2.1 Numeric Encoding](#21-numeric-encoding)

     

       15
       15
       +
           - [2.2 String Encoding](#22-string-encoding)

     

       16
       16
       +
       - [3. Type System](#3-type-system)

     

       17
       17
       +
           - [3.1 Type Identifiers](#31-type-identifiers)

     

       18
       18
       +
           - [3.2 Array-Compatible Types](#32-array-compatible-types)

     

       19
       19
       +
           - [3.3 Map Key Compatible Types](#33-map-key-compatible-types)

     

       20
       20
       +
       - [4. Binary Encoding](#4-binary-encoding)

     

       21
       21
       +
           - [4.1 Primitive Types](#41-primitive-types)

     

       22
       22
       +
               - [4.1.1 Integer Types](#411-integer-types)

     

       23
       23
       +
               - [4.1.2 Floating-Point Types](#412-floating-point-types)

     

       24
       24
       +
               - [4.1.3 Boolean](#413-boolean)

     

       25
       25
       +
           - [4.2 String Type](#42-string-type)

     

       26
       26
       +
           - [4.3 Option Type](#43-option-type)

     

       27
       27
       +
           - [4.4 List Type (Heterogeneous)](#44-list-type-heterogeneous)

     

       28
       28
       +
           - [4.5 Map Type](#45-map-type)

     

       29
       29
       +
           - [4.6 Array Type (Homogeneous)](#46-array-type-homogeneous)

     

       30
       30
       +
           - [4.7 Timestamp Type](#47-timestamp-type)

     

       31
       31
       +
           - [4.8 UUID Type](#48-uuid-type)

     

       32
       32
       +
       - [5. File Format](#5-file-format)

     

       33
       33
       +
           - [5.1 File Structure](#51-file-structure)

     

       34
       34
       +
           - [5.2 Header Format](#52-header-format)

     

       35
       35
       +
               - [5.2.1 Magic Bytes](#521-magic-bytes)

     

       36
       36
       +
                   - [5.2.1.1 File Extension and MIME type](#5211-file-extension-and-mime-type)

     

       37
       37
       +
               - [5.2.2 Version](#522-version)

     

       38
       38
       +
               - [5.2.3 Flags](#523-flags)

     

       39
       39
       +
               - [5.2.4 Compression Method](#524-compression-method)

     

       40
       40
       +
               - [5.2.5 Payload Length](#525-payload-length)

     

       41
       41
       +
           - [5.3 Payload](#53-payload)

     

       42
       42
       +
       - [6. Example](#6-example)

     

       43
       43
       +
       - [7. Conformance Requirements](#7-conformance-requirements)

     

       44
       44
       +
       

     

       45
       45
       +
       <!-- TOC end -->

     

       46
       46
       +
       

     

       47
       47
       +
       <!-- TOC --><a name="1-overview"></a>

     

       48
       48
       +
       

     

       49
       49
       +
       ## 1. Overview

     

       50
       50
       +
       

     

       51
       51
       +
       NBT2 (Named Binary Tag version 2) is a binary serialization format designed to

     

       52
       52
       +
       address limitations of the original NBT format while maintaining simplicity and

     

       53
       53
       +
       efficiency.

     

       54
       54
       +
       

     

       55
       55
       +
       <!-- TOC --><a name="11-key-changes"></a>

     

       56
       56
       +
       

     

       57
       57
       +
       ### 1.1 Key Changes

     

       58
       58
       +
       

     

       59
       59
       +
       - Explicit `Option` type for nullable values

     

       60
       60
       +
       - Support for both heterogeneous lists and homogeneous arrays

     

       61
       61
       +
       - Clear distinction between signed and unsigned integer types

     

       62
       62
       +
       - Built-in support for timestamps, UUIDs, and boolean values

     

       63
       63
       +
       

     

       64
       64
       +
       <!-- TOC --><a name="2-data-representation"></a>

     

       65
       65
       +
       

     

       66
       66
       +
       ## 2. Data Representation

     

       67
       67
       +
       

     

       68
       68
       +
       <!-- TOC --><a name="21-numeric-encoding"></a>

     

       69
       69
       +
       

     

       70
       70
       +
       ### 2.1 Numeric Encoding

     

       71
       71
       +
       

     

       72
       72
       +
       - Unsigned integers: Standard binary representation

     

       73
       73
       +
       - Signed integers: Two's complement representation

     

       74
       74
       +
       - Floating-point: IEEE 754 standard (binary32 for f32, binary64 for f64)

     

       75
       75
       +
       - Endianness: Determined by file header flags (see Section 4.2.4)

     

       76
       76
       +
       

     

       77
       77
       +
       <!-- TOC --><a name="22-string-encoding"></a>

     

       78
       78
       +
       

     

       79
       79
       +
       ### 2.2 String Encoding

     

       80
       80
       +
       

     

       81
       81
       +
       All strings MUST be encoded as UTF-8. Alternate encoding schemes, such as Java's

     

       82
       82
       +
       [Modified UTF-8][mutf8], are explicitly NOT supported.

     

       83
       83
       +
       

     

       84
       84
       +
       <!-- TOC --><a name="3-type-system"></a>

     

       85
       85
       +
       

     

       86
       86
       +
       ## 3. Type System

     

       87
       87
       +
       

     

       88
       88
       +
       <!-- TOC --><a name="31-type-identifiers"></a>

     

       89
       89
       +
       

     

       90
       90
       +
       ### 3.1 Type Identifiers

     

       91
       91
       +
       

     

       92
       92
       +
       | ID   | Type      | Description                   | Size (bytes) |

     

       93
       93
       +
       | ---- | --------- | ----------------------------- | ------------ |

     

       94
       94
       +
       | 0x00 | u8        | Unsigned 8-bit integer        | 1            |

     

       95
       95
       +
       | 0x01 | i8        | Signed 8-bit integer          | 1            |

     

       96
       96
       +
       | 0x02 | u16       | Unsigned 16-bit integer       | 2            |

     

       97
       97
       +
       | 0x03 | i16       | Signed 16-bit integer         | 2            |

     

       98
       98
       +
       | 0x04 | u32       | Unsigned 32-bit integer       | 4            |

     

       99
       99
       +
       | 0x05 | i32       | Signed 32-bit integer         | 4            |

     

       100
       100
       +
       | 0x06 | u64       | Unsigned 64-bit integer       | 8            |

     

       101
       101
       +
       | 0x07 | i64       | Signed 64-bit integer         | 8            |

     

       102
       102
       +
       | 0x08 | f32       | 32-bit IEEE 754 float         | 4            |

     

       103
       103
       +
       | 0x09 | f64       | 64-bit IEEE 754 float         | 8            |

     

       104
       104
       +
       | 0x0A | bool      | Boolean value                 | 1            |

     

       105
       105
       +
       | 0x0B | String    | UTF-8 encoded string          | Variable     |

     

       106
       106
       +
       | 0x0C | Option    | Optional value container      | Variable     |

     

       107
       107
       +
       | 0x0D | List      | Heterogeneous array           | Variable     |

     

       108
       108
       +
       | 0x0E | Map       | Key-value dictionary          | Variable     |

     

       109
       109
       +
       | 0x0F | Array     | Homogeneous typed array       | Variable     |

     

       110
       110
       +
       | 0x10 | Timestamp | Unix timestamp (milliseconds) | 8            |

     

       111
       111
       +
       | 0x11 | UUID      | 128-bit UUID                  | 16           |

     

       112
       112
       +
       

     

       113
       113
       +
       **Note**: Type IDs 0x12-0xFF are reserved for future expansion.

     

       114
       114
       +
       

     

       115
       115
       +
       <!-- TOC --><a name="32-array-compatible-types"></a>

     

       116
       116
       +
       

     

       117
       117
       +
       ### 3.2 Array-Compatible Types

     

       118
       118
       +
       

     

       119
       119
       +
       The following types are valid as `Array` element types:

     

       120
       120
       +
       

     

       121
       121
       +
       - All integer types: `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64`

     

       122
       122
       +
       - All floating-point types: `f32`, `f64`

     

       123
       123
       +
       - Boolean type: `bool`

     

       124
       124
       +
       

     

       125
       125
       +
       Complex types (`String`, `Option`, `List`, `Map`, `Array`, `Timestamp`, `UUID`)

     

       126
       126
       +
       MUST use the heterogeneous `List` type.

     

       127
       127
       +
       

     

       128
       128
       +
       <!-- TOC --><a name="33-map-key-compatible-types"></a>

     

       129
       129
       +
       

     

       130
       130
       +
       ### 3.3 Map Key Compatible Types

     

       131
       131
       +
       

     

       132
       132
       +
       All types are valid as `Map` key types except:

     

       133
       133
       +
       

     

       134
       134
       +
       - `Option`

     

       135
       135
       +
       - `List`

     

       136
       136
       +
       - `Map`

     

       137
       137
       +
       - `Array`

     

       138
       138
       +
       

     

       139
       139
       +
       <!-- TOC --><a name="4-binary-encoding"></a>

     

       140
       140
       +
       

     

       141
       141
       +
       ## 4. Binary Encoding

     

       142
       142
       +
       

     

       143
       143
       +
       <!-- TOC --><a name="41-primitive-types"></a>

     

       144
       144
       +
       

     

       145
       145
       +
       ### 4.1 Primitive Types

     

       146
       146
       +
       

     

       147
       147
       +
       <!-- TOC --><a name="411-integer-types"></a>

     

       148
       148
       +
       

     

       149
       149
       +
       #### 4.1.1 Integer Types

     

       150
       150
       +
       

     

       151
       151
       +
       ```

     

       152
       152
       +
       [type_id: u8] [value: T]

     

       153
       153
       +
       ```

     

       154
       154
       +
       

     

       155
       155
       +
       Where `T` is the appropriately-sized integer in the file's endianness.

     

       156
       156
       +
       

     

       157
       157
       +
       <!-- TOC --><a name="412-floating-point-types"></a>

     

       158
       158
       +
       

     

       159
       159
       +
       #### 4.1.2 Floating-Point Types

     

       160
       160
       +
       

     

       161
       161
       +
       ```

     

       162
       162
       +
       [type_id: u8] [value: T]

     

       163
       163
       +
       ```

     

       164
       164
       +
       

     

       165
       165
       +
       Where `T` follows IEEE 754 encoding in the file's endianness.

     

       166
       166
       +
       

     

       167
       167
       +
       <!-- TOC --><a name="413-boolean"></a>

     

       168
       168
       +
       

     

       169
       169
       +
       #### 4.1.3 Boolean

     

       170
       170
       +
       

     

       171
       171
       +
       ```

     

       172
       172
       +
       [type_id: u8] [value: u8]

     

       173
       173
       +
       ```

     

       174
       174
       +
       

     

       175
       175
       +
       - `0x00`: false

     

       176
       176
       +
       - `0x01`: true

     

       177
       177
       +
       - All other values are invalid

     

       178
       178
       +
       

     

       179
       179
       +
       <!-- TOC --><a name="42-string-type"></a>

     

       180
       180
       +
       

     

       181
       181
       +
       ### 4.2 String Type

     

       182
       182
       +
       

     

       183
       183
       +
       ```

     

       184
       184
       +
       [type_id: u8] [length: u32] [utf8_data: [u8; length]]

     

       185
       185
       +
       ```

     

       186
       186
       +
       

     

       187
       187
       +
       - `length`: Number of bytes in UTF-8 encoding

     

       188
       188
       +
       - `utf8_data`: Valid UTF-8 byte sequence

     

       189
       189
       +
       - Empty strings have length 0 and no data bytes

     

       190
       190
       +
       

     

       191
       191
       +
       <!-- TOC --><a name="43-option-type"></a>

     

       192
       192
       +
       

     

       193
       193
       +
       ### 4.3 Option Type

     

       194
       194
       +
       

     

       195
       195
       +
       ```

     

       196
       196
       +
       [type_id: u8] [inner_type_id: u8] [discriminant: u8] [payload?]

     

       197
       197
       +
       ```

     

       198
       198
       +
       

     

       199
       199
       +
       - `inner_type_id`: Type ID of the contained value

     

       200
       200
       +
       - `discriminant`:

     

       201
       201
       +
           - `0x00`: None (no payload follows)

     

       202
       202
       +
           - `0x01`: Some (payload follows)

     

       203
       203
       +
       - `payload`: Present only when discriminant is `0x01`

     

       204
       204
       +
       

     

       205
       205
       +
       **Examples:**

     

       206
       206
       +
       

     

       207
       207
       +
       - `Option<u32>::None`: `[0x0C] [0x04] [0x00]`

     

       208
       208
       +
       - `Option<u32>::Some(42)`: `[0x0C] [0x04] [0x01] [42, 0, 0, 0]` (little-endian)

     

       209
       209
       +
       

     

       210
       210
       +
       <!-- TOC --><a name="44-list-type-heterogeneous"></a>

     

       211
       211
       +
       

     

       212
       212
       +
       ### 4.4 List Type (Heterogeneous)

     

       213
       213
       +
       

     

       214
       214
       +
       ```

     

       215
       215
       +
       [type_id: u8] [length: u32] [element_1] [element_2] ... [element_n]

     

       216
       216
       +
       ```

     

       217
       217
       +
       

     

       218
       218
       +
       - `length`: Number of elements

     

       219
       219
       +
       - Each element is a complete typed value (type_id + data)

     

       220
       220
       +
       - Elements may have different types

     

       221
       221
       +
       

     

       222
       222
       +
       **Example:** List `[42u8, "hello", true]`

     

       223
       223
       +
       

     

       224
       224
       +
       ```

     

       225
       225
       +
       [0x0D]                              // List type

     

       226
       226
       +
       [3, 0, 0, 0]                        // 3 elements

     

       227
       227
       +
       [0x00] [42]                         // u8: 42

     

       228
       228
       +
       [0x0B] [5, 0, 0, 0] [h, e, l, l, o] // String: "hello"

     

       229
       229
       +
       [0x0A] [1]                          // bool: true

     

       230
       230
       +
       ```

     

       231
       231
       +
       

     

       232
       232
       +
       <!-- TOC --><a name="45-map-type"></a>

     

       233
       233
       +
       

     

       234
       234
       +
       ### 4.5 Map Type

     

       235
       235
       +
       

     

       236
       236
       +
       ```

     

       237
       237
       +
       [type_id: u8] [length: u32] [pair_1] [pair_2] ... [pair_n]

     

       238
       238
       +
       ```

     

       239
       239
       +
       

     

       240
       240
       +
       Each key-value pair:

     

       241
       241
       +
       

     

       242
       242
       +
       ```

     

       243
       243
       +
       [key] [value]

     

       244
       244
       +
       ```

     

       245
       245
       +
       

     

       246
       246
       +
       - `length`: Number of key-value pairs

     

       247
       247
       +
       - Both `key` and `value` are complete typed values

     

       248
       248
       +
       - `key` MUST be a map key compatible type (see Section 3.3)

     

       249
       249
       +
       - Keys SHOULD be unique (behavior for duplicate keys is undefined)

     

       250
       250
       +
       

     

       251
       251
       +
       **Example:** Map `{42u8: "answer", "pi": 3.14f32}`

     

       252
       252
       +
       

     

       253
       253
       +
       ```

     

       254
       254
       +
       [0x0E] [2, 0, 0, 0]                                        // Map with 2 pairs

     

       255
       255
       +
       [0x00] [42] [0x0B] [6, 0, 0, 0] [a, n, s, w, e, r]         // 42u8 -> "answer"

     

       256
       256
       +
       [0x0B] [2, 0, 0, 0] [p, i] [0x08] [0xC3, 0xF5, 0x48, 0x40] // "pi" -> 3.14f32

     

       257
       257
       +
       ```

     

       258
       258
       +
       

     

       259
       259
       +
       <!-- TOC --><a name="46-array-type-homogeneous"></a>

     

       260
       260
       +
       

     

       261
       261
       +
       ### 4.6 Array Type (Homogeneous)

     

       262
       262
       +
       

     

       263
       263
       +
       ```

     

       264
       264
       +
       [type_id: u8] [length: u32] [element_type_id: u8] [element_1] ... [element_n]

     

       265
       265
       +
       ```

     

       266
       266
       +
       

     

       267
       267
       +
       - `length`: Number of elements

     

       268
       268
       +
       - `element_type_id`: Must be an array-compatible type (see Section 3.2)

     

       269
       269
       +
       - Elements are stored as raw values (no type_id prefix per element)

     

       270
       270
       +
       

     

       271
       271
       +
       **Example:** `i32` array `[1, 2, 3]`

     

       272
       272
       +
       

     

       273
       273
       +
       ```

     

       274
       274
       +
       [0x0F]           // Array type

     

       275
       275
       +
       [3, 0, 0, 0]     // 3 elements

     

       276
       276
       +
       [0x05]           // element type: i32

     

       277
       277
       +
       [1, 0, 0, 0]     // 1

     

       278
       278
       +
       [2, 0, 0, 0]     // 2

     

       279
       279
       +
       [3, 0, 0, 0]     // 3

     

       280
       280
       +
       ```

     

       281
       281
       +
       

     

       282
       282
       +
       <!-- TOC --><a name="47-timestamp-type"></a>

     

       283
       283
       +
       

     

       284
       284
       +
       ### 4.7 Timestamp Type

     

       285
       285
       +
       

     

       286
       286
       +
       ```

     

       287
       287
       +
       [type_id: u8] [value: i64]

     

       288
       288
       +
       ```

     

       289
       289
       +
       

     

       290
       290
       +
       - `value`: Milliseconds since Unix epoch

     

       291
       291
       +
       - Negative values represent times before the epoch

     

       292
       292
       +
       

     

       293
       293
       +
       <!-- TOC --><a name="48-uuid-type"></a>

     

       294
       294
       +
       

     

       295
       295
       +
       ### 4.8 UUID Type

     

       296
       296
       +
       

     

       297
       297
       +
       ```

     

       298
       298
       +
       [type_id: u8] [bytes: [u8; 16]]

     

       299
       299
       +
       ```

     

       300
       300
       +
       

     

       301
       301
       +
       - `bytes`: 16 bytes representing the UUID in **big-endian** byte order

     

       302
       302
       +
       - Follows [RFC 4122][rfc4122] standard binary representation

     

       303
       303
       +
       - Byte order is independent of file endianness flag

     

       304
       304
       +
       

     

       305
       305
       +
       **Example:** UUID `550e8400-e29b-41d4-a716-446655440000`

     

       306
       306
       +
       

     

       307
       307
       +
       ```

     

       308
       308
       +
       [0x11]                                           // UUID type

     

       309
       309
       +
       [0x55, 0x0e, 0x84, 0x00, 0xe2, 0x9b, 0x41, 0xd4, // UUID bytes

     

       310
       310
       +
        0xa7, 0x16, 0x44, 0x66, 0x55, 0x44, 0x00, 0x00] //  (big-endian)

     

       311
       311
       +
       ```

     

       312
       312
       +
       

     

       313
       313
       +
       <!-- TOC --><a name="5-file-format"></a>

     

       314
       314
       +
       

     

       315
       315
       +
       ## 5. File Format

     

       316
       316
       +
       

     

       317
       317
       +
       <!-- TOC --><a name="51-file-structure"></a>

     

       318
       318
       +
       

     

       319
       319
       +
       ### 5.1 File Structure

     

       320
       320
       +
       

     

       321
       321
       +
       ```

     

       322
       322
       +
       [header] [payload]

     

       323
       323
       +
       ```

     

       324
       324
       +
       

     

       325
       325
       +
       <!-- TOC --><a name="52-header-format"></a>

     

       326
       326
       +
       

     

       327
       327
       +
       ### 5.2 Header Format

     

       328
       328
       +
       

     

       329
       329
       +
       ```

     

       330
       330
       +
       [magic: [u8; 4]] [version: u8] [flags: u8] [compression: u8] [payload_length: u32]

     

       331
       331
       +
       ```

     

       332
       332
       +
       

     

       333
       333
       +
       <!-- TOC --><a name="521-magic-bytes"></a>

     

       334
       334
       +
       

     

       335
       335
       +
       #### 5.2.1 Magic Bytes

     

       336
       336
       +
       

     

       337
       337
       +
       Fixed 4-byte signature: `NBT2` (0x4E, 0x42, 0x54, 0x32).

     

       338
       338
       +
       

     

       339
       339
       +
       <!-- TOC --><a name="5211-file-extension-and-mime-type"></a>

     

       340
       340
       +
       

     

       341
       341
       +
       ##### 5.2.1.1 File Extension and MIME type

     

       342
       342
       +
       

     

       343
       343
       +
       The recommended file extension is `.nbt2`. The recommended MIME type is

     

       344
       344
       +
       `application/x-nbt2`.

     

       345
       345
       +
       

     

       346
       346
       +
       <!-- TOC --><a name="522-version"></a>

     

       347
       347
       +
       

     

       348
       348
       +
       #### 5.2.2 Version

     

       349
       349
       +
       

     

       350
       350
       +
       - `0x01`: NBT2.1 (current version)

     

       351
       351
       +
       - Future versions increment this value

     

       352
       352
       +
       

     

       353
       353
       +
       <!-- TOC --><a name="523-flags"></a>

     

       354
       354
       +
       

     

       355
       355
       +
       #### 5.2.3 Flags

     

       356
       356
       +
       

     

       357
       357
       +
       8-bit flag field:

     

       358
       358
       +
       

     

       359
       359
       +
       - Bit 0: Endianness (0 = little-endian, 1 = big-endian)

     

       360
       360
       +
       - Bits 1-7: Reserved (MUST be zero)

     

       361
       361
       +
       

     

       362
       362
       +
       <!-- TOC --><a name="524-compression-method"></a>

     

       363
       363
       +
       

     

       364
       364
       +
       #### 5.2.4 Compression Method

     

       365
       365
       +
       

     

       366
       366
       +
       - `0x00`: No compression

     

       367
       367
       +
       - `0x01`: Gzip compression ([RFC 1952][rfc1952])

     

       368
       368
       +
       - `0x02`: Zlib compression ([RFC 1950][rfc1950])

     

       369
       369
       +
       - `0x03`: LZ4 compression

     

       370
       370
       +
       - `0x04-0xFF`: Reserved for future compression methods

     

       371
       371
       +
       

     

       372
       372
       +
       <!-- TOC --><a name="525-payload-length"></a>

     

       373
       373
       +
       

     

       374
       374
       +
       #### 5.2.5 Payload Length

     

       375
       375
       +
       

     

       376
       376
       +
       - Length of payload in bytes (u32, in file's endianness)

     

       377
       377
       +
       - For compressed files: length of compressed data

     

       378
       378
       +
       - For uncompressed files: length of raw NBT2 data

     

       379
       379
       +
       

     

       380
       380
       +
       <!-- TOC --><a name="53-payload"></a>

     

       381
       381
       +
       

     

       382
       382
       +
       ### 5.3 Payload

     

       383
       383
       +
       

     

       384
       384
       +
       The payload contains a single root typed value, typically a `Map`. Unlike NBT,

     

       385
       385
       +
       the root value has no name.

     

       386
       386
       +
       

     

       387
       387
       +
       <!-- TOC --><a name="6-example"></a>

     

       388
       388
       +
       

     

       389
       389
       +
       ## 6. Example

     

       390
       390
       +
       

     

       391
       391
       +
       Complete uncompressed little-endian file containing `{"test": 42i32}`:

     

       392
       392
       +
       

     

       393
       393
       +
       ```

     

       394
       394
       +
       [0x4E, 0x42, 0x54, 0x32]          // Magic: "NBT2"

     

       395
       395
       +
       [0x01]                            // Version: 2.1

     

       396
       396
       +
       [0x00]                            // Flags: little-endian

     

       397
       397
       +
       [0x00]                            // Compression: none

     

       398
       398
       +
       [23, 0, 0, 0]                     // Payload length: 23 bytes

     

       399
       399
       +
       

     

       400
       400
       +
       // Payload: Map with one entry

     

       401
       401
       +
       [0x0E]                            // Map type

     

       402
       402
       +
       [1, 0, 0, 0]                      // 1 key-value pair

     

       403
       403
       +
       [0x0B] [4, 0, 0, 0] [t, e, s, t]  // String key: "test"

     

       404
       404
       +
       [0x05] [42, 0, 0, 0]              // i32 value: 42

     

       405
       405
       +
       ```

     

       406
       406
       +
       

     

       407
       407
       +
       <!-- TOC --><a name="7-conformance-requirements"></a>

     

       408
       408
       +
       

     

       409
       409
       +
       ## 7. Conformance Requirements

     

       410
       410
       +
       

     

       411
       411
       +
       - Implementations MUST reject files with invalid magic bytes

     

       412
       412
       +
       - Implementations MUST support at least version `0x01`

     

       413
       413
       +
       - Unknown compression methods SHOULD be rejected

     

       414
       414
       +
       - Invalid UTF-8 in strings MUST be rejected

     

       415
       415
       +
       - Boolean values other than 0x00/0x01 MUST be rejected

     

       416
       416
       +
       - Reserved flag bits MUST be zero in generated files

     

       417
       417
       +
       

     

       418
       418
       +
       [rfc2119]: https://www.rfc-editor.org/rfc/rfc2119

     

       419
       419
       +
       [mutf8]: https://docs.oracle.com/en/java/javase/23/docs/api/java.base/java/io/DataInput.html#modified-utf-8

     

       420
       420
       +
       [rfc1950]: https://www.rfc-editor.org/rfc/rfc1950

     

       421
       421
       +
       [rfc1952]: https://www.rfc-editor.org/rfc/rfc1952

     

       422
       422
       +
       [rfc4122]: https://www.rfc-editor.org/rfc/rfc4122

+20

crates/migrate/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "nbt2_migrate"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       license = "MIT OR Apache-2.0"

     

       6
       6
       +
       rust-version = "1.89"

     

       7
       7
       +
       description = "Data transformations for the NBT2 format."

     

       8
       8
       +
       

     

       9
       9
       +
       [dependencies]

     

       10
       10
       +
       nbtree_core.workspace = true

     

       11
       11
       +
       thiserror.workspace = true

     

       12
       12
       +
       uuid.workspace = true

     

       13
       13
       +
       

     

       14
       14
       +
       nbt2 = { path = "../..", version = "0.1.0" }

     

       15
       15
       +
       

     

       16
       16
       +
       [dev-dependencies]

     

       17
       17
       +
       insta.workspace = true

     

       18
       18
       +
       

     

       19
       19
       +
       [lints]

     

       20
       20
       +
       workspace = true

crates/migrate/README.md

···

       1
       1
       +
       # nbt2_migrate

     

       2
       2
       +
       

     

       3
       3
       +
       Provides data transformations for the NBT2 format.

     

       4
       4
       +
       

     

       5
       5
       +
       In the future this should provide utilities for converting between NBT2

     

       6
       6
       +
       versions, but for now it just contains a simple NBT->NBT2 conversion.

crates/migrate/src/lib.rs

···

       1
       1
       +
       //! Data transformations for the NBT2 format.

     

       2
       2
       +
       //!

     

       3
       3
       +
       //! In the future this should provide utilities for converting between NBT2

     

       4
       4
       +
       //! versions, but for now it just contains a simple NBT->NBT2 conversion.

     

       5
       5
       +
       pub mod nbt;

+163

crates/migrate/src/nbt.rs

···

       1
       1
       +
       //! Conversion utilities for converting NBT tags to NBT2 format.

     

       2
       2
       +
       use nbt2::{Tag, TagKind};

     

       3
       3
       +
       use nbtree_core::nbt::{Tag as NBTTag, TagId as NBTTagKind};

     

       4
       4
       +
       use uuid::Uuid;

     

       5
       5
       +
       

     

       6
       6
       +
       #[derive(Debug, Clone, thiserror::Error)]

     

       7
       7
       +
       pub enum Error {

     

       8
       8
       +
           #[error("Cannot convert NBT kind '{0:?}' to NBT2.")]

     

       9
       9
       +
           CannotConvertKind(NBTTagKind),

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       pub type Result<T> = core::result::Result<T, Error>;

     

       13
       13
       +
       

     

       14
       14
       +
       #[derive(Debug, Clone)]

     

       15
       15
       +
       pub struct ConversionOptions {

     

       16
       16
       +
           /// Whether the converter should attempt to read Int Arrays with 4 items or

     

       17
       17
       +
           /// Long Arrays with 2 items as UUIDs (strictly v4).

     

       18
       18
       +
           pub attempt_to_convert_uuids: bool,

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       impl Default for ConversionOptions {

     

       22
       22
       +
           fn default() -> Self {

     

       23
       23
       +
               Self {

     

       24
       24
       +
                   attempt_to_convert_uuids: false,

     

       25
       25
       +
               }

     

       26
       26
       +
           }

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       impl ConversionOptions {

     

       30
       30
       +
           pub fn attempt_to_convert_uuids(mut self, convert: bool) -> Self {

     

       31
       31
       +
               self.attempt_to_convert_uuids = convert;

     

       32
       32
       +
               self

     

       33
       33
       +
           }

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       /// Converts an NBT tag to its NBT2 equivalent.

     

       37
       37
       +
       ///

     

       38
       38
       +
       /// This function performs a recursive conversion of NBT data structures

     

       39
       39
       +
       /// to NBT2 format, handling the differences between the two formats:

     

       40
       40
       +
       ///

     

       41
       41
       +
       /// - NBT byte/int/long arrays become NBT2 `Array<i8>`/`Array<i32>`/`Array<i64>`

     

       42
       42
       +
       /// - NBT lists of primitive types become NBT2 homogeneous `Array`s

     

       43
       43
       +
       /// - NBT lists of complex types become NBT2 heterogeneous `List`s

     

       44
       44
       +
       /// - NBT compounds become NBT2 `Map`s with string keys

     

       45
       45
       +
       pub fn convert_tag(tag: NBTTag, opts: &ConversionOptions) -> Result<Tag> {

     

       46
       46
       +
           match tag {

     

       47
       47
       +
               NBTTag::End => Err(Error::CannotConvertKind(NBTTagKind::End)),

     

       48
       48
       +
               NBTTag::Byte(byte) => Ok(Tag::I8(byte)),

     

       49
       49
       +
               NBTTag::Short(short) => Ok(Tag::I16(short)),

     

       50
       50
       +
               NBTTag::Int(int) => Ok(Tag::I32(int)),

     

       51
       51
       +
               NBTTag::Long(long) => Ok(Tag::I64(long)),

     

       52
       52
       +
               NBTTag::Float(float) => Ok(Tag::F32(float)),

     

       53
       53
       +
               NBTTag::Double(double) => Ok(Tag::F64(double)),

     

       54
       54
       +
               NBTTag::ByteArray(bytes) => Ok(Tag::Array(

     

       55
       55
       +
                   TagKind::I8,

     

       56
       56
       +
                   bytes.into_iter().map(Tag::I8).collect(),

     

       57
       57
       +
               )),

     

       58
       58
       +
               NBTTag::String(string) => Ok(Tag::String(string)),

     

       59
       59
       +
               NBTTag::List(tag_kind, tags) => match tag_kind {

     

       60
       60
       +
                   NBTTagKind::Byte

     

       61
       61
       +
                   | NBTTagKind::Short

     

       62
       62
       +
                   | NBTTagKind::Int

     

       63
       63
       +
                   | NBTTagKind::Long

     

       64
       64
       +
                   | NBTTagKind::Float

     

       65
       65
       +
                   | NBTTagKind::Double => {

     

       66
       66
       +
                       let converted_kind = match tag_kind {

     

       67
       67
       +
                           NBTTagKind::Byte => TagKind::I8,

     

       68
       68
       +
                           NBTTagKind::Short => TagKind::I16,

     

       69
       69
       +
                           NBTTagKind::Int => TagKind::I32,

     

       70
       70
       +
                           NBTTagKind::Long => TagKind::I64,

     

       71
       71
       +
                           NBTTagKind::Float => TagKind::F32,

     

       72
       72
       +
                           NBTTagKind::Double => TagKind::F64,

     

       73
       73
       +
                           _ => unreachable!(

     

       74
       74
       +
                               "tag_kind should be one of the primitive types, got: {:?} despite already matching.",

     

       75
       75
       +
                               tag_kind

     

       76
       76
       +
                           ),

     

       77
       77
       +
                       };

     

       78
       78
       +
       

     

       79
       79
       +
                       let converted_tags: core::result::Result<Vec<Tag>, _> = tags

     

       80
       80
       +
                           .into_iter()

     

       81
       81
       +
                           .map(|tag| convert_tag(tag, opts))

     

       82
       82
       +
                           .collect();

     

       83
       83
       +
       

     

       84
       84
       +
                       Ok(Tag::Array(converted_kind, converted_tags?))

     

       85
       85
       +
                   }

     

       86
       86
       +
                   _ => {

     

       87
       87
       +
                       let converted_tags: Result<Vec<Tag>> = tags

     

       88
       88
       +
                           .into_iter()

     

       89
       89
       +
                           .map(|tag| convert_tag(tag, opts))

     

       90
       90
       +
                           .collect();

     

       91
       91
       +
                       Ok(Tag::List(converted_tags?))

     

       92
       92
       +
                   }

     

       93
       93
       +
               },

     

       94
       94
       +
               NBTTag::Compound(index_map) => {

     

       95
       95
       +
                   let converted_map: Result<Vec<(Tag, Tag)>> = index_map

     

       96
       96
       +
                       .into_iter()

     

       97
       97
       +
                       .map(|(key, value)| {

     

       98
       98
       +
                           Ok((Tag::String(key), convert_tag(*value, opts)?))

     

       99
       99
       +
                       })

     

       100
       100
       +
                       .collect();

     

       101
       101
       +
                   Ok(Tag::Map(converted_map?))

     

       102
       102
       +
               }

     

       103
       103
       +
               NBTTag::IntArray(items) => {

     

       104
       104
       +
                   if items.len() == 4 && opts.attempt_to_convert_uuids {

     

       105
       105
       +
                       let bytes: [u8; 16] = [

     

       106
       106
       +
                           (items[0] >> 24) as u8,

     

       107
       107
       +
                           (items[0] >> 16) as u8,

     

       108
       108
       +
                           (items[0] >> 8) as u8,

     

       109
       109
       +
                           items[0] as u8,

     

       110
       110
       +
                           (items[1] >> 24) as u8,

     

       111
       111
       +
                           (items[1] >> 16) as u8,

     

       112
       112
       +
                           (items[1] >> 8) as u8,

     

       113
       113
       +
                           items[1] as u8,

     

       114
       114
       +
                           (items[2] >> 24) as u8,

     

       115
       115
       +
                           (items[2] >> 16) as u8,

     

       116
       116
       +
                           (items[2] >> 8) as u8,

     

       117
       117
       +
                           items[2] as u8,

     

       118
       118
       +
                           (items[3] >> 24) as u8,

     

       119
       119
       +
                           (items[3] >> 16) as u8,

     

       120
       120
       +
                           (items[3] >> 8) as u8,

     

       121
       121
       +
                           items[3] as u8,

     

       122
       122
       +
                       ];

     

       123
       123
       +
       

     

       124
       124
       +
                       let uuid = Uuid::from_bytes(bytes);

     

       125
       125
       +
       

     

       126
       126
       +
                       if uuid.get_version() == Some(uuid::Version::Random) {

     

       127
       127
       +
                           return Ok(Tag::Uuid(uuid));

     

       128
       128
       +
                       } else {

     

       129
       129
       +
                           return Ok(Tag::Array(

     

       130
       130
       +
                               TagKind::I32,

     

       131
       131
       +
                               items.into_iter().map(Tag::I32).collect(),

     

       132
       132
       +
                           ));

     

       133
       133
       +
                       }

     

       134
       134
       +
                   } else {

     

       135
       135
       +
                       Ok(Tag::Array(

     

       136
       136
       +
                           TagKind::I32,

     

       137
       137
       +
                           items.into_iter().map(Tag::I32).collect(),

     

       138
       138
       +
                       ))

     

       139
       139
       +
                   }

     

       140
       140
       +
               }

     

       141
       141
       +
               NBTTag::LongArray(items) => {

     

       142
       142
       +
                   if items.len() == 2 && opts.attempt_to_convert_uuids {

     

       143
       143
       +
                       let most = items[0] as u64; // treating as raw bits

     

       144
       144
       +
                       let least = items[1] as u64; // ditto

     

       145
       145
       +
                       let uuid = Uuid::from_u64_pair(most, least);

     

       146
       146
       +
       

     

       147
       147
       +
                       if uuid.get_version() == Some(uuid::Version::Random) {

     

       148
       148
       +
                           Ok(Tag::Uuid(uuid))

     

       149
       149
       +
                       } else {

     

       150
       150
       +
                           Ok(Tag::Array(

     

       151
       151
       +
                               TagKind::I64,

     

       152
       152
       +
                               items.into_iter().map(Tag::I64).collect(),

     

       153
       153
       +
                           ))

     

       154
       154
       +
                       }

     

       155
       155
       +
                   } else {

     

       156
       156
       +
                       Ok(Tag::Array(

     

       157
       157
       +
                           TagKind::I64,

     

       158
       158
       +
                           items.into_iter().map(Tag::I64).collect(),

     

       159
       159
       +
                       ))

     

       160
       160
       +
                   }

     

       161
       161
       +
               }

     

       162
       162
       +
           }

     

       163
       163
       +
       }

+18

crates/migrate/tests/snapshots/test_nbt__int_array_uuid_does_not_convert.snap

···

       1
       1
       +
       ---

     

       2
       2
       +
       source: crates/migrate/tests/test_nbt.rs

     

       3
       3
       +
       expression: tags

     

       4
       4
       +
       ---

     

       5
       5
       +
       [

     

       6
       6
       +
           I32(

     

       7
       7
       +
               -1983734701,

     

       8
       8
       +
           ),

     

       9
       9
       +
           I32(

     

       10
       10
       +
               -284420573,

     

       11
       11
       +
           ),

     

       12
       12
       +
           I32(

     

       13
       13
       +
               -1832185991,

     

       14
       14
       +
           ),

     

       15
       15
       +
           I32(

     

       16
       16
       +
               -1828022334,

     

       17
       17
       +
           ),

     

       18
       18
       +
       ]

+12

crates/migrate/tests/snapshots/test_nbt__long_array_uuid_does_not_convert.snap

···

       1
       1
       +
       ---

     

       2
       2
       +
       source: crates/migrate/tests/test_nbt.rs

     

       3
       3
       +
       expression: tags

     

       4
       4
       +
       ---

     

       5
       5
       +
       [

     

       6
       6
       +
           I64(

     

       7
       7
       +
               -8520075660724783581,

     

       8
       8
       +
           ),

     

       9
       9
       +
           I64(

     

       10
       10
       +
               -7869178909067405374,

     

       11
       11
       +
           ),

     

       12
       12
       +
       ]

+155

crates/migrate/tests/test_nbt.rs

···

       1
       1
       +
       use std::str::FromStr;

     

       2
       2
       +
       

     

       3
       3
       +
       use insta::assert_debug_snapshot;

     

       4
       4
       +
       use nbt2;

     

       5
       5
       +
       use nbt2_migrate::nbt::ConversionOptions;

     

       6
       6
       +
       use nbtree_core::nbt;

     

       7
       7
       +
       use uuid::Uuid;

     

       8
       8
       +
       

     

       9
       9
       +
       #[test]

     

       10
       10
       +
       fn test_int_array_uuid_does_convert() {

     

       11
       11
       +
           let nbt_tag = nbt::Tag::IntArray(vec![

     

       12
       12
       +
               -1983734701,

     

       13
       13
       +
               -284408285,

     

       14
       14
       +
               -1832185991,

     

       15
       15
       +
               -1828022334,

     

       16
       16
       +
           ]);

     

       17
       17
       +
       

     

       18
       18
       +
           let converted = nbt2_migrate::nbt::convert_tag(

     

       19
       19
       +
               nbt_tag,

     

       20
       20
       +
               &ConversionOptions::default().attempt_to_convert_uuids(true),

     

       21
       21
       +
           )

     

       22
       22
       +
           .unwrap();

     

       23
       23
       +
       

     

       24
       24
       +
           if let nbt2::Tag::Uuid(uuid) = converted {

     

       25
       25
       +
               assert_eq!(

     

       26
       26
       +
                   uuid,

     

       27
       27
       +
                   Uuid::from_str("89c29c53-ef0c-4623-92cb-0f79930a97c2").unwrap()

     

       28
       28
       +
               );

     

       29
       29
       +
           } else {

     

       30
       30
       +
               panic!(

     

       31
       31
       +
                   "Expected NBT2 tag kind of Uuid, got {0:?}",

     

       32
       32
       +
                   converted.kind()

     

       33
       33
       +
               )

     

       34
       34
       +
           }

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       #[test]

     

       38
       38
       +
       fn test_int_array_uuid_does_not_convert() {

     

       39
       39
       +
           let nbt_tag = nbt::Tag::IntArray(vec![

     

       40
       40
       +
               -1983734701,

     

       41
       41
       +
               -284420573, // not version 4

     

       42
       42
       +
               -1832185991,

     

       43
       43
       +
               -1828022334,

     

       44
       44
       +
           ]);

     

       45
       45
       +
       

     

       46
       46
       +
           let converted = nbt2_migrate::nbt::convert_tag(

     

       47
       47
       +
               nbt_tag,

     

       48
       48
       +
               &ConversionOptions::default().attempt_to_convert_uuids(true),

     

       49
       49
       +
           )

     

       50
       50
       +
           .unwrap();

     

       51
       51
       +
       

     

       52
       52
       +
           if let nbt2::Tag::Array(kind, tags) = converted {

     

       53
       53
       +
               assert_eq!(kind, nbt2::TagKind::I32);

     

       54
       54
       +
               assert_eq!(tags.len(), 4);

     

       55
       55
       +
       

     

       56
       56
       +
               assert_debug_snapshot!(tags);

     

       57
       57
       +
           } else {

     

       58
       58
       +
               panic!(

     

       59
       59
       +
                   "Expected NBT2 tag kind of Array, got {0:?}",

     

       60
       60
       +
                   converted.kind()

     

       61
       61
       +
               )

     

       62
       62
       +
           }

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       #[test]

     

       66
       66
       +
       fn test_int_array_wrong_length_does_not_convert() {

     

       67
       67
       +
           let nbt_tag = nbt::Tag::IntArray(vec![

     

       68
       68
       +
               -1983734701,

     

       69
       69
       +
               -284408285,

     

       70
       70
       +
               -1832185991,

     

       71
       71
       +
               -1828022334,

     

       72
       72
       +
               123456789,

     

       73
       73
       +
           ]);

     

       74
       74
       +
           let converted = nbt2_migrate::nbt::convert_tag(

     

       75
       75
       +
               nbt_tag,

     

       76
       76
       +
               &ConversionOptions::default().attempt_to_convert_uuids(true),

     

       77
       77
       +
           )

     

       78
       78
       +
           .unwrap();

     

       79
       79
       +
           if let nbt2::Tag::Array(kind, tags) = converted {

     

       80
       80
       +
               assert_eq!(kind, nbt2::TagKind::I32);

     

       81
       81
       +
               assert_eq!(tags.len(), 5);

     

       82
       82
       +
           } else {

     

       83
       83
       +
               panic!(

     

       84
       84
       +
                   "Expected NBT2 tag kind of Array, got {0:?}",

     

       85
       85
       +
                   converted.kind()

     

       86
       86
       +
               )

     

       87
       87
       +
           }

     

       88
       88
       +
       }

     

       89
       89
       +
       

     

       90
       90
       +
       #[test]

     

       91
       91
       +
       fn test_long_array_uuid_does_convert() {

     

       92
       92
       +
           let nbt_tag =

     

       93
       93
       +
               nbt::Tag::LongArray(vec![-8520075660724779485, -7869178909067405374]);

     

       94
       94
       +
           let converted = nbt2_migrate::nbt::convert_tag(

     

       95
       95
       +
               nbt_tag,

     

       96
       96
       +
               &ConversionOptions::default().attempt_to_convert_uuids(true),

     

       97
       97
       +
           )

     

       98
       98
       +
           .unwrap();

     

       99
       99
       +
           if let nbt2::Tag::Uuid(uuid) = converted {

     

       100
       100
       +
               assert_eq!(

     

       101
       101
       +
                   uuid,

     

       102
       102
       +
                   Uuid::from_str("89c29c53-ef0c-4623-92cb-0f79930a97c2").unwrap()

     

       103
       103
       +
               );

     

       104
       104
       +
           } else {

     

       105
       105
       +
               panic!(

     

       106
       106
       +
                   "Expected NBT2 tag kind of Uuid, got {0:?}",

     

       107
       107
       +
                   converted.kind()

     

       108
       108
       +
               )

     

       109
       109
       +
           }

     

       110
       110
       +
       }

     

       111
       111
       +
       

     

       112
       112
       +
       #[test]

     

       113
       113
       +
       fn test_long_array_uuid_does_not_convert() {

     

       114
       114
       +
           let nbt_tag = nbt::Tag::LongArray(vec![

     

       115
       115
       +
               -8520075660724783581, // not version 4

     

       116
       116
       +
               -7869178909067405374,

     

       117
       117
       +
           ]);

     

       118
       118
       +
           let converted = nbt2_migrate::nbt::convert_tag(

     

       119
       119
       +
               nbt_tag,

     

       120
       120
       +
               &ConversionOptions::default().attempt_to_convert_uuids(true),

     

       121
       121
       +
           )

     

       122
       122
       +
           .unwrap();

     

       123
       123
       +
           if let nbt2::Tag::Array(kind, tags) = converted {

     

       124
       124
       +
               assert_eq!(kind, nbt2::TagKind::I64);

     

       125
       125
       +
               assert_debug_snapshot!(tags);

     

       126
       126
       +
           } else {

     

       127
       127
       +
               panic!(

     

       128
       128
       +
                   "Expected NBT2 tag kind of Array, got {0:?}",

     

       129
       129
       +
                   converted.kind()

     

       130
       130
       +
               )

     

       131
       131
       +
           }

     

       132
       132
       +
       }

     

       133
       133
       +
       

     

       134
       134
       +
       #[test]

     

       135
       135
       +
       fn test_long_array_wrong_length_does_not_convert() {

     

       136
       136
       +
           let nbt_tag = nbt::Tag::LongArray(vec![

     

       137
       137
       +
               -8520075660724779485,

     

       138
       138
       +
               -7869178909067405374,

     

       139
       139
       +
               123456789,

     

       140
       140
       +
           ]);

     

       141
       141
       +
           let converted = nbt2_migrate::nbt::convert_tag(

     

       142
       142
       +
               nbt_tag,

     

       143
       143
       +
               &ConversionOptions::default().attempt_to_convert_uuids(true),

     

       144
       144
       +
           )

     

       145
       145
       +
           .unwrap();

     

       146
       146
       +
           if let nbt2::Tag::Array(kind, tags) = converted {

     

       147
       147
       +
               assert_eq!(kind, nbt2::TagKind::I64);

     

       148
       148
       +
               assert_eq!(tags.len(), 3);

     

       149
       149
       +
           } else {

     

       150
       150
       +
               panic!(

     

       151
       151
       +
                   "Expected NBT2 tag kind of Array, got {0:?}",

     

       152
       152
       +
                   converted.kind()

     

       153
       153
       +
               )

     

       154
       154
       +
           }

     

       155
       155
       +
       }

rustfmt.toml

···

       1
       1
       +
       max_width = 80

src/len.rs

···

       1
       1
       +
       pub const BYTE: usize = 1;

     

       2
       2
       +
       pub const INT_8: usize = BYTE;

     

       3
       3
       +
       pub const INT_16: usize = BYTE * 2;

     

       4
       4
       +
       pub const INT_32: usize = BYTE * 4;

     

       5
       5
       +
       pub const INT_64: usize = BYTE * 8;

     

       6
       6
       +
       pub const FLOAT_32: usize = BYTE * 4;

     

       7
       7
       +
       pub const FLOAT_64: usize = BYTE * 8;

     

       8
       8
       +
       pub const UUID: usize = 16;

     

       9
       9
       +
       pub const MAGIC_BYTES: usize = BYTE * 4;

+266

src/lib.rs

···

       1
       1
       +
       pub(crate) mod len;

     

       2
       2
       +
       pub mod reader;

     

       3
       3
       +
       pub mod writer;

     

       4
       4
       +
       

     

       5
       5
       +
       /// Kinds of [`Tag`]s.

     

       6
       6
       +
       #[derive(Debug, Clone, Copy, PartialEq, Eq)]

     

       7
       7
       +
       #[repr(u8)]

     

       8
       8
       +
       pub enum TagKind {

     

       9
       9
       +
           U8 = 0x00,

     

       10
       10
       +
           I8 = 0x01,

     

       11
       11
       +
           U16 = 0x02,

     

       12
       12
       +
           I16 = 0x03,

     

       13
       13
       +
           U32 = 0x04,

     

       14
       14
       +
           I32 = 0x05,

     

       15
       15
       +
           U64 = 0x06,

     

       16
       16
       +
           I64 = 0x07,

     

       17
       17
       +
           F32 = 0x08,

     

       18
       18
       +
           F64 = 0x09,

     

       19
       19
       +
           Bool = 0x0A,

     

       20
       20
       +
           String = 0x0B,

     

       21
       21
       +
           Option = 0x0C,

     

       22
       22
       +
           List = 0x0D,

     

       23
       23
       +
           Map = 0x0E,

     

       24
       24
       +
           Array = 0x0F,

     

       25
       25
       +
           Timestamp = 0x10,

     

       26
       26
       +
           Uuid = 0x11,

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       impl TagKind {

     

       30
       30
       +
           pub fn from_byte(byte: u8) -> Option<TagKind> {

     

       31
       31
       +
               match byte {

     

       32
       32
       +
                   0x00 => Some(TagKind::U8),

     

       33
       33
       +
                   0x01 => Some(TagKind::I8),

     

       34
       34
       +
                   0x02 => Some(TagKind::U16),

     

       35
       35
       +
                   0x03 => Some(TagKind::I16),

     

       36
       36
       +
                   0x04 => Some(TagKind::U32),

     

       37
       37
       +
                   0x05 => Some(TagKind::I32),

     

       38
       38
       +
                   0x06 => Some(TagKind::U64),

     

       39
       39
       +
                   0x07 => Some(TagKind::I64),

     

       40
       40
       +
                   0x08 => Some(TagKind::F32),

     

       41
       41
       +
                   0x09 => Some(TagKind::F64),

     

       42
       42
       +
                   0x0A => Some(TagKind::Bool),

     

       43
       43
       +
                   0x0B => Some(TagKind::String),

     

       44
       44
       +
                   0x0C => Some(TagKind::Option),

     

       45
       45
       +
                   0x0D => Some(TagKind::List),

     

       46
       46
       +
                   0x0E => Some(TagKind::Map),

     

       47
       47
       +
                   0x0F => Some(TagKind::Array),

     

       48
       48
       +
                   0x10 => Some(TagKind::Timestamp),

     

       49
       49
       +
                   0x11 => Some(TagKind::Uuid),

     

       50
       50
       +
                   _ => None,

     

       51
       51
       +
               }

     

       52
       52
       +
           }

     

       53
       53
       +
       

     

       54
       54
       +
           pub fn valid_for_array_element(&self) -> bool {

     

       55
       55
       +
               matches!(

     

       56
       56
       +
                   self,

     

       57
       57
       +
                   TagKind::U8

     

       58
       58
       +
                       | TagKind::I8

     

       59
       59
       +
                       | TagKind::U16

     

       60
       60
       +
                       | TagKind::I16

     

       61
       61
       +
                       | TagKind::U32

     

       62
       62
       +
                       | TagKind::I32

     

       63
       63
       +
                       | TagKind::U64

     

       64
       64
       +
                       | TagKind::I64

     

       65
       65
       +
                       | TagKind::F32

     

       66
       66
       +
                       | TagKind::F64

     

       67
       67
       +
                       | TagKind::Bool

     

       68
       68
       +
               )

     

       69
       69
       +
           }

     

       70
       70
       +
       

     

       71
       71
       +
           pub fn valid_for_map_key(&self) -> bool {

     

       72
       72
       +
               !matches!(

     

       73
       73
       +
                   self,

     

       74
       74
       +
                   TagKind::Option | TagKind::List | TagKind::Array | TagKind::Map

     

       75
       75
       +
               )

     

       76
       76
       +
           }

     

       77
       77
       +
       }

     

       78
       78
       +
       

     

       79
       79
       +
       /// NBT2 Tags.

     

       80
       80
       +
       #[derive(Debug, Clone, PartialEq)]

     

       81
       81
       +
       pub enum Tag {

     

       82
       82
       +
           U8(u8),

     

       83
       83
       +
           I8(i8),

     

       84
       84
       +
           U16(u16),

     

       85
       85
       +
           I16(i16),

     

       86
       86
       +
           U32(u32),

     

       87
       87
       +
           I32(i32),

     

       88
       88
       +
           U64(u64),

     

       89
       89
       +
           I64(i64),

     

       90
       90
       +
           F32(f32),

     

       91
       91
       +
           F64(f64),

     

       92
       92
       +
           Bool(bool),

     

       93
       93
       +
           String(String),

     

       94
       94
       +
           Option(TagKind, Option<Box<Tag>>),

     

       95
       95
       +
           List(Vec<Tag>),

     

       96
       96
       +
           Map(Vec<(Tag, Tag)>),

     

       97
       97
       +
           /// Holds a list of `Tag`s of one kind.

     

       98
       98
       +
           Array(TagKind, Vec<Tag>),

     

       99
       99
       +
           Timestamp(chrono::DateTime<chrono::Utc>),

     

       100
       100
       +
           Uuid(uuid::Uuid),

     

       101
       101
       +
       }

     

       102
       102
       +
       

     

       103
       103
       +
       macro_rules! simple_tag_constructors {

     

       104
       104
       +
           ( $( $fn_name:ident : $variant:ident ( $ty:ty ) ),* $(,)? ) => {

     

       105
       105
       +
               $(

     

       106
       106
       +
                   #[doc = concat!("Creates a new [`Tag::", stringify!($variant), "`].")]

     

       107
       107
       +
                   pub fn $fn_name(value: $ty) -> Self {

     

       108
       108
       +
                       Tag::$variant(value)

     

       109
       109
       +
                   }

     

       110
       110
       +
               )*

     

       111
       111
       +
           };

     

       112
       112
       +
       }

     

       113
       113
       +
       

     

       114
       114
       +
       impl Tag {

     

       115
       115
       +
           simple_tag_constructors! {

     

       116
       116
       +
               new_u8: U8(u8),

     

       117
       117
       +
               new_i8: I8(i8),

     

       118
       118
       +
               new_u16: U16(u16),

     

       119
       119
       +
               new_i16: I16(i16),

     

       120
       120
       +
               new_u32: U32(u32),

     

       121
       121
       +
               new_i32: I32(i32),

     

       122
       122
       +
               new_u64: U64(u64),

     

       123
       123
       +
               new_i64: I64(i64),

     

       124
       124
       +
               new_f32: F32(f32),

     

       125
       125
       +
               new_f64: F64(f64),

     

       126
       126
       +
               new_bool: Bool(bool),

     

       127
       127
       +
           }

     

       128
       128
       +
       

     

       129
       129
       +
           /// Creates a new [`Tag::String`].

     

       130
       130
       +
           pub fn new_string<S: Into<String>>(s: S) -> Self {

     

       131
       131
       +
               Tag::String(s.into())

     

       132
       132
       +
           }

     

       133
       133
       +
       

     

       134
       134
       +
           /// Creates a new [`Tag::Option`] containing the given `Tag`.

     

       135
       135
       +
           pub fn new_option(kind: TagKind, value: Option<Tag>) -> Self {

     

       136
       136
       +
               Tag::Option(kind, value.map(Box::new))

     

       137
       137
       +
           }

     

       138
       138
       +
       

     

       139
       139
       +
           /// Creates a new [`Tag::List`] from a vector of `Tag`s.

     

       140
       140
       +
           pub fn new_list(values: Vec<Tag>) -> Self {

     

       141
       141
       +
               Tag::List(values)

     

       142
       142
       +
           }

     

       143
       143
       +
       

     

       144
       144
       +
           /// Creates a new [`Tag::Map`] from a vector of key-value pairs.

     

       145
       145
       +
           pub fn new_map(entries: Vec<(Tag, Tag)>) -> Self {

     

       146
       146
       +
               Tag::Map(entries)

     

       147
       147
       +
           }

     

       148
       148
       +
       

     

       149
       149
       +
           /// Creates a new [`Tag::Array`] of the specified [`TagKind`] and elements.

     

       150
       150
       +
           pub fn new_array(kind: TagKind, elements: Vec<Tag>) -> Self {

     

       151
       151
       +
               Tag::Array(kind, elements)

     

       152
       152
       +
           }

     

       153
       153
       +
       

     

       154
       154
       +
           /// Creates a new [`Tag::Timestamp`] from a [`chrono::DateTime<Utc>`].

     

       155
       155
       +
           pub fn new_timestamp(value: chrono::DateTime<chrono::Utc>) -> Self {

     

       156
       156
       +
               Tag::Timestamp(value)

     

       157
       157
       +
           }

     

       158
       158
       +
       

     

       159
       159
       +
           /// Creates a new [`Tag::Uuid`] from a [`uuid::Uuid`].

     

       160
       160
       +
           pub fn new_uuid(value: uuid::Uuid) -> Self {

     

       161
       161
       +
               Tag::Uuid(value)

     

       162
       162
       +
           }

     

       163
       163
       +
       

     

       164
       164
       +
           /// Get this `Tag`'s [`TagKind`].

     

       165
       165
       +
           pub fn kind(&self) -> TagKind {

     

       166
       166
       +
               match self {

     

       167
       167
       +
                   Tag::U8 { .. } => TagKind::U8,

     

       168
       168
       +
                   Tag::I8 { .. } => TagKind::I8,

     

       169
       169
       +
                   Tag::U16 { .. } => TagKind::U16,

     

       170
       170
       +
                   Tag::I16 { .. } => TagKind::I16,

     

       171
       171
       +
                   Tag::U32 { .. } => TagKind::U32,

     

       172
       172
       +
                   Tag::I32 { .. } => TagKind::I32,

     

       173
       173
       +
                   Tag::U64 { .. } => TagKind::U64,

     

       174
       174
       +
                   Tag::I64 { .. } => TagKind::I64,

     

       175
       175
       +
                   Tag::F32 { .. } => TagKind::F32,

     

       176
       176
       +
                   Tag::F64 { .. } => TagKind::F64,

     

       177
       177
       +
                   Tag::Bool { .. } => TagKind::Bool,

     

       178
       178
       +
                   Tag::String { .. } => TagKind::String,

     

       179
       179
       +
                   Tag::Option { .. } => TagKind::Option,

     

       180
       180
       +
                   Tag::List { .. } => TagKind::List,

     

       181
       181
       +
                   Tag::Map { .. } => TagKind::Map,

     

       182
       182
       +
                   Tag::Array { .. } => TagKind::Array,

     

       183
       183
       +
                   Tag::Timestamp { .. } => TagKind::Timestamp,

     

       184
       184
       +
                   Tag::Uuid { .. } => TagKind::Uuid,

     

       185
       185
       +
               }

     

       186
       186
       +
           }

     

       187
       187
       +
       }

     

       188
       188
       +
       

     

       189
       189
       +
       /// File header for NBT2 files.

     

       190
       190
       +
       #[derive(Debug, Clone, Copy, PartialEq, Eq)]

     

       191
       191
       +
       pub struct FileHeader {

     

       192
       192
       +
           pub version: u8,

     

       193
       193
       +
           pub little_endian: bool,

     

       194
       194
       +
           pub compression: CompressionMethod,

     

       195
       195
       +
           pub payload_length: u32,

     

       196
       196
       +
       }

     

       197
       197
       +
       

     

       198
       198
       +
       impl FileHeader {

     

       199
       199
       +
           pub const MAGIC_BYTES: [u8; len::MAGIC_BYTES] = [b'N', b'B', b'T', b'2'];

     

       200
       200
       +
       

     

       201
       201
       +
           pub const CURRENT_VERSION: u8 = 1;

     

       202
       202
       +
       

     

       203
       203
       +
           pub fn new(compression: CompressionMethod, payload_length: u32) -> Self {

     

       204
       204
       +
               Self {

     

       205
       205
       +
                   version: Self::CURRENT_VERSION,

     

       206
       206
       +
                   little_endian: true,

     

       207
       207
       +
                   compression,

     

       208
       208
       +
                   payload_length,

     

       209
       209
       +
               }

     

       210
       210
       +
           }

     

       211
       211
       +
       }

     

       212
       212
       +
       

     

       213
       213
       +
       /// Compression methods supported by NBT2.

     

       214
       214
       +
       #[derive(Debug, Clone, Copy, PartialEq, Eq)]

     

       215
       215
       +
       #[repr(u8)]

     

       216
       216
       +
       pub enum CompressionMethod {

     

       217
       217
       +
           None = 0x00,

     

       218
       218
       +
           Gzip = 0x01,

     

       219
       219
       +
           Zlib = 0x02,

     

       220
       220
       +
           Lz4 = 0x03,

     

       221
       221
       +
       }

     

       222
       222
       +
       

     

       223
       223
       +
       impl CompressionMethod {

     

       224
       224
       +
           pub fn from_byte(byte: u8) -> Option<CompressionMethod> {

     

       225
       225
       +
               match byte {

     

       226
       226
       +
                   0x00 => Some(CompressionMethod::None),

     

       227
       227
       +
                   0x01 => Some(CompressionMethod::Gzip),

     

       228
       228
       +
                   0x02 => Some(CompressionMethod::Zlib),

     

       229
       229
       +
                   0x03 => Some(CompressionMethod::Lz4),

     

       230
       230
       +
                   _ => None,

     

       231
       231
       +
               }

     

       232
       232
       +
           }

     

       233
       233
       +
       }

     

       234
       234
       +
       

     

       235
       235
       +
       /// Errors that can occur during NBT2 operations.

     

       236
       236
       +
       #[derive(Debug, thiserror::Error)]

     

       237
       237
       +
       pub enum Error {

     

       238
       238
       +
           #[error("Unexpected end of file")]

     

       239
       239
       +
           UnexpectedEof,

     

       240
       240
       +
           #[error("Invalid magic bytes sequence '{0:02X?}'")]

     

       241
       241
       +
           InvalidMagic([u8; len::MAGIC_BYTES]),

     

       242
       242
       +
           #[error("Unsupported version 0x{0:x}")]

     

       243
       243
       +
           UnsupportedVersion(u8),

     

       244
       244
       +
           #[error("Unsupported compression method {0:?}")]

     

       245
       245
       +
           UnsupportedCompression(CompressionMethod),

     

       246
       246
       +
           #[error("Unknown compression method type 0x{0:x}")]

     

       247
       247
       +
           UnknownCompression(u8),

     

       248
       248
       +
           #[error("Invalid tag ID 0x{0:x}")]

     

       249
       249
       +
           InvalidTagKind(u8),

     

       250
       250
       +
           #[error("Encountered an invalid UTF-8 sequence: {0}")]

     

       251
       251
       +
           InvalidUtf8(#[from] std::string::FromUtf8Error),

     

       252
       252
       +
           #[error("Invalid boolean value 0x{0:x}")]

     

       253
       253
       +
           InvalidBoolValue(u8),

     

       254
       254
       +
           #[error("Invalid Option discriminant 0x{0:x}")]

     

       255
       255
       +
           InvalidOptionDiscriminant(u8),

     

       256
       256
       +
           #[error("Invalid Option kind 0x{0:?}, expected 0x{1:?}")]

     

       257
       257
       +
           InvalidOptionKind(TagKind, TagKind),

     

       258
       258
       +
           #[error("Invalid element kind for Array tag '{0:?}'")]

     

       259
       259
       +
           InvalidArrayTagKind(TagKind),

     

       260
       260
       +
           #[error("IO error: {0}")]

     

       261
       261
       +
           IoError(#[from] std::io::Error),

     

       262
       262
       +
           #[error("Milliseconds for Timestamp are out of range: {0}")]

     

       263
       263
       +
           MillisecondsOutOfRange(i64),

     

       264
       264
       +
       }

     

       265
       265
       +
       

     

       266
       266
       +
       pub type Result<T> = core::result::Result<T, Error>;

+322

src/reader.rs

···

       1
       1
       +
       use crate::{CompressionMethod, Error, FileHeader, Result, Tag, TagKind, len};

     

       2
       2
       +
       use std::io::Read;

     

       3
       3
       +
       

     

       4
       4
       +
       use chrono::DateTime;

     

       5
       5
       +
       #[cfg(feature = "gzip")]

     

       6
       6
       +
       use flate2::read::{GzDecoder, ZlibDecoder};

     

       7
       7
       +
       #[cfg(feature = "lz4")]

     

       8
       8
       +
       use lz4::Decoder;

     

       9
       9
       +
       use uuid::Uuid;

     

       10
       10
       +
       

     

       11
       11
       +
       pub struct Reader {

     

       12
       12
       +
           reader: Box<dyn Read>,

     

       13
       13
       +
           position: usize,

     

       14
       14
       +
           header: FileHeader,

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       impl Reader {

     

       18
       18
       +
           /// Create a Reader that automatically wraps the underlying reader in a

     

       19
       19
       +
           /// decompressor based on the compression method in the header.

     

       20
       20
       +
           pub fn new<R: Read + 'static>(mut reader: R) -> Result<Self> {

     

       21
       21
       +
               let header = Self::read_header(&mut reader)?;

     

       22
       22
       +
       

     

       23
       23
       +
               let reader: Box<dyn Read> = match header.compression {

     

       24
       24
       +
                   CompressionMethod::None => Box::new(reader),

     

       25
       25
       +
                   CompressionMethod::Gzip => {

     

       26
       26
       +
                       #[cfg(feature = "gzip")]

     

       27
       27
       +
                       {

     

       28
       28
       +
                           Box::new(GzDecoder::new(reader))

     

       29
       29
       +
                       }

     

       30
       30
       +
                       #[cfg(not(feature = "gzip"))]

     

       31
       31
       +
                       {

     

       32
       32
       +
                           return Err(Error::UnsupportedCompression(

     

       33
       33
       +
                               header.compression,

     

       34
       34
       +
                           ));

     

       35
       35
       +
                       }

     

       36
       36
       +
                   }

     

       37
       37
       +
                   CompressionMethod::Zlib => {

     

       38
       38
       +
                       #[cfg(feature = "gzip")]

     

       39
       39
       +
                       {

     

       40
       40
       +
                           Box::new(ZlibDecoder::new(reader))

     

       41
       41
       +
                       }

     

       42
       42
       +
                       #[cfg(not(feature = "gzip"))]

     

       43
       43
       +
                       {

     

       44
       44
       +
                           return Err(Error::UnsupportedCompression(

     

       45
       45
       +
                               header.compression,

     

       46
       46
       +
                           ));

     

       47
       47
       +
                       }

     

       48
       48
       +
                   }

     

       49
       49
       +
                   CompressionMethod::Lz4 => {

     

       50
       50
       +
                       #[cfg(feature = "lz4")]

     

       51
       51
       +
                       {

     

       52
       52
       +
                           Box::new(Decoder::new(reader).map_err(Error::IoError)?)

     

       53
       53
       +
                       }

     

       54
       54
       +
                       #[cfg(not(feature = "lz4"))]

     

       55
       55
       +
                       {

     

       56
       56
       +
                           return Err(Error::UnsupportedCompression(

     

       57
       57
       +
                               header.compression,

     

       58
       58
       +
                           ));

     

       59
       59
       +
                       }

     

       60
       60
       +
                   }

     

       61
       61
       +
               };

     

       62
       62
       +
       

     

       63
       63
       +
               Ok(Self {

     

       64
       64
       +
                   reader,

     

       65
       65
       +
                   position: 0,

     

       66
       66
       +
                   header,

     

       67
       67
       +
               })

     

       68
       68
       +
           }

     

       69
       69
       +
       

     

       70
       70
       +
           fn read_header<R: Read + 'static>(reader: &mut R) -> Result<FileHeader> {

     

       71
       71
       +
               let mut magic_bytes = [0u8; len::MAGIC_BYTES];

     

       72
       72
       +
               reader

     

       73
       73
       +
                   .read_exact(&mut magic_bytes)

     

       74
       74
       +
                   .map_err(|_| Error::UnexpectedEof)?;

     

       75
       75
       +
               if magic_bytes != FileHeader::MAGIC_BYTES {

     

       76
       76
       +
                   return Err(Error::InvalidMagic(magic_bytes));

     

       77
       77
       +
               }

     

       78
       78
       +
       

     

       79
       79
       +
               let mut version_byte = [0u8; len::BYTE];

     

       80
       80
       +
               reader.read_exact(&mut version_byte)?;

     

       81
       81
       +
               let version = version_byte[0];

     

       82
       82
       +
               if version != FileHeader::CURRENT_VERSION {

     

       83
       83
       +
                   return Err(Error::UnsupportedVersion(version));

     

       84
       84
       +
               }

     

       85
       85
       +
       

     

       86
       86
       +
               let mut flag_byte = [0u8; len::BYTE];

     

       87
       87
       +
               reader.read_exact(&mut flag_byte)?;

     

       88
       88
       +
               let little_endian = flag_byte[0] == 0;

     

       89
       89
       +
       

     

       90
       90
       +
               let mut compression_byte = [0u8; len::BYTE];

     

       91
       91
       +
               reader.read_exact(&mut compression_byte)?;

     

       92
       92
       +
               let compression = CompressionMethod::from_byte(compression_byte[0])

     

       93
       93
       +
                   .ok_or(Error::UnknownCompression(compression_byte[0]))?;

     

       94
       94
       +
       

     

       95
       95
       +
               let mut length_bytes = [0u8; len::INT_32];

     

       96
       96
       +
               reader.read_exact(&mut length_bytes)?;

     

       97
       97
       +
               let payload_length = if little_endian {

     

       98
       98
       +
                   u32::from_le_bytes(length_bytes)

     

       99
       99
       +
               } else {

     

       100
       100
       +
                   u32::from_be_bytes(length_bytes)

     

       101
       101
       +
               };

     

       102
       102
       +
       

     

       103
       103
       +
               Ok(FileHeader {

     

       104
       104
       +
                   version,

     

       105
       105
       +
                   little_endian,

     

       106
       106
       +
                   compression,

     

       107
       107
       +
                   payload_length,

     

       108
       108
       +
               })

     

       109
       109
       +
           }

     

       110
       110
       +
       

     

       111
       111
       +
           pub fn file_header(&self) -> &FileHeader {

     

       112
       112
       +
               &self.header

     

       113
       113
       +
           }

     

       114
       114
       +
       

     

       115
       115
       +
           pub fn read_tag(&mut self) -> Result<Tag> {

     

       116
       116
       +
               let kind = self.read_tag_kind()?;

     

       117
       117
       +
               self.read_tag_of_kind(kind)

     

       118
       118
       +
           }

     

       119
       119
       +
       

     

       120
       120
       +
           fn read_tag_of_kind(&mut self, kind: TagKind) -> Result<Tag> {

     

       121
       121
       +
               match kind {

     

       122
       122
       +
                   TagKind::U8 => Ok(Tag::U8(self.read_u8()?)),

     

       123
       123
       +
                   TagKind::I8 => Ok(Tag::I8(self.read_i8()?)),

     

       124
       124
       +
                   TagKind::U16 => Ok(Tag::U16(self.read_u16()?)),

     

       125
       125
       +
                   TagKind::I16 => Ok(Tag::I16(self.read_i16()?)),

     

       126
       126
       +
                   TagKind::U32 => Ok(Tag::U32(self.read_u32()?)),

     

       127
       127
       +
                   TagKind::I32 => Ok(Tag::I32(self.read_i32()?)),

     

       128
       128
       +
                   TagKind::U64 => Ok(Tag::U64(self.read_u64()?)),

     

       129
       129
       +
                   TagKind::I64 => Ok(Tag::I64(self.read_i64()?)),

     

       130
       130
       +
                   TagKind::F32 => Ok(Tag::F32(self.read_f32()?)),

     

       131
       131
       +
                   TagKind::F64 => Ok(Tag::F64(self.read_f64()?)),

     

       132
       132
       +
                   TagKind::Bool => Ok(Tag::Bool(self.read_bool()?)),

     

       133
       133
       +
                   TagKind::String => Ok(Tag::String(self.read_string()?)),

     

       134
       134
       +
                   TagKind::Option => Ok(self.read_option()?),

     

       135
       135
       +
                   TagKind::List => Ok(self.read_list()?),

     

       136
       136
       +
                   TagKind::Map => Ok(self.read_map()?),

     

       137
       137
       +
                   TagKind::Array => Ok(self.read_array()?),

     

       138
       138
       +
                   TagKind::Timestamp => Ok(self.read_timestamp()?),

     

       139
       139
       +
                   TagKind::Uuid => Ok(self.read_uuid()?),

     

       140
       140
       +
               }

     

       141
       141
       +
           }

     

       142
       142
       +
       

     

       143
       143
       +
           fn read_option(&mut self) -> Result<Tag> {

     

       144
       144
       +
               let kind_byte = self.read_u8()?;

     

       145
       145
       +
               let kind = TagKind::from_byte(kind_byte)

     

       146
       146
       +
                   .ok_or(Error::InvalidTagKind(kind_byte))?;

     

       147
       147
       +
               let discriminant = self.read_u8()?;

     

       148
       148
       +
               match discriminant {

     

       149
       149
       +
                   0x00 => Ok(Tag::Option(kind, None)),

     

       150
       150
       +
                   0x01 => {

     

       151
       151
       +
                       let inner = self.read_tag_of_kind(kind)?;

     

       152
       152
       +
                       if kind != inner.kind() {

     

       153
       153
       +
                           // shouldn't happen but doesnt hurt to check

     

       154
       154
       +
                           return Err(Error::InvalidOptionKind(inner.kind(), kind));

     

       155
       155
       +
                       }

     

       156
       156
       +
                       Ok(Tag::Option(kind, Some(Box::new(inner))))

     

       157
       157
       +
                   }

     

       158
       158
       +
                   _ => Err(Error::InvalidOptionDiscriminant(discriminant)),

     

       159
       159
       +
               }

     

       160
       160
       +
           }

     

       161
       161
       +
       

     

       162
       162
       +
           fn read_list(&mut self) -> Result<Tag> {

     

       163
       163
       +
               let length = self.read_u32()? as usize;

     

       164
       164
       +
               let mut elements = Vec::with_capacity(length);

     

       165
       165
       +
       

     

       166
       166
       +
               for _ in 0..length {

     

       167
       167
       +
                   elements.push(self.read_tag()?);

     

       168
       168
       +
               }

     

       169
       169
       +
       

     

       170
       170
       +
               Ok(Tag::List(elements))

     

       171
       171
       +
           }

     

       172
       172
       +
       

     

       173
       173
       +
           fn read_array(&mut self) -> Result<Tag> {

     

       174
       174
       +
               let length = self.read_u32()? as usize;

     

       175
       175
       +
               let element_kind = self.read_tag_kind()?;

     

       176
       176
       +
       

     

       177
       177
       +
               if !element_kind.valid_for_array_element() {

     

       178
       178
       +
                   return Err(Error::InvalidArrayTagKind(element_kind));

     

       179
       179
       +
               }

     

       180
       180
       +
       

     

       181
       181
       +
               let mut elements = Vec::with_capacity(length);

     

       182
       182
       +
       

     

       183
       183
       +
               for _ in 0..length {

     

       184
       184
       +
                   elements.push(self.read_tag_of_kind(element_kind)?);

     

       185
       185
       +
               }

     

       186
       186
       +
       

     

       187
       187
       +
               Ok(Tag::Array(element_kind, elements))

     

       188
       188
       +
           }

     

       189
       189
       +
       

     

       190
       190
       +
           fn read_map(&mut self) -> Result<Tag> {

     

       191
       191
       +
               let length = self.read_u32()? as usize;

     

       192
       192
       +
               let mut elements = Vec::with_capacity(length);

     

       193
       193
       +
       

     

       194
       194
       +
               for _ in 0..length {

     

       195
       195
       +
                   let key = self.read_tag()?;

     

       196
       196
       +
                   let value = self.read_tag()?;

     

       197
       197
       +
       

     

       198
       198
       +
                   elements.push((key, value));

     

       199
       199
       +
               }

     

       200
       200
       +
       

     

       201
       201
       +
               Ok(Tag::Map(elements))

     

       202
       202
       +
           }

     

       203
       203
       +
       

     

       204
       204
       +
           fn read_timestamp(&mut self) -> Result<Tag> {

     

       205
       205
       +
               let ms = self.read_i64()?;

     

       206
       206
       +
               let dt = DateTime::from_timestamp_millis(ms)

     

       207
       207
       +
                   .ok_or(Error::MillisecondsOutOfRange(ms))?;

     

       208
       208
       +
               Ok(Tag::Timestamp(dt))

     

       209
       209
       +
           }

     

       210
       210
       +
       

     

       211
       211
       +
           fn read_uuid(&mut self) -> Result<Tag> {

     

       212
       212
       +
               Ok(Tag::Uuid(Uuid::from_bytes(

     

       213
       213
       +
                   self.read_bytes::<{ len::UUID }>()?,

     

       214
       214
       +
               )))

     

       215
       215
       +
           }

     

       216
       216
       +
       

     

       217
       217
       +
           // primitives

     

       218
       218
       +
       

     

       219
       219
       +
           fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {

     

       220
       220
       +
               self.reader

     

       221
       221
       +
                   .read_exact(buf)

     

       222
       222
       +
                   .map_err(|_| Error::UnexpectedEof)?;

     

       223
       223
       +
               self.position += buf.len();

     

       224
       224
       +
               Ok(())

     

       225
       225
       +
           }

     

       226
       226
       +
       

     

       227
       227
       +
           fn read_bytes<const N: usize>(&mut self) -> Result<[u8; N]> {

     

       228
       228
       +
               let mut buf = [0u8; N];

     

       229
       229
       +
               self.read_exact(&mut buf)?;

     

       230
       230
       +
               Ok(buf)

     

       231
       231
       +
           }

     

       232
       232
       +
       

     

       233
       233
       +
           fn read_bytes_vec(&mut self, n: usize) -> Result<Vec<u8>> {

     

       234
       234
       +
               let mut buf = vec![0u8; n];

     

       235
       235
       +
               self.read_exact(&mut buf)?;

     

       236
       236
       +
               Ok(buf)

     

       237
       237
       +
           }

     

       238
       238
       +
       

     

       239
       239
       +
           fn read_tag_kind(&mut self) -> Result<TagKind> {

     

       240
       240
       +
               let byte = self.read_u8()?;

     

       241
       241
       +
               TagKind::from_byte(byte).ok_or(Error::InvalidTagKind(byte))

     

       242
       242
       +
           }

     

       243
       243
       +
       

     

       244
       244
       +
           fn read_bool(&mut self) -> Result<bool> {

     

       245
       245
       +
               match self.read_u8()? {

     

       246
       246
       +
                   0 => Ok(false),

     

       247
       247
       +
                   1 => Ok(true),

     

       248
       248
       +
                   v => Err(Error::InvalidBoolValue(v)),

     

       249
       249
       +
               }

     

       250
       250
       +
           }

     

       251
       251
       +
       

     

       252
       252
       +
           fn read_u8(&mut self) -> Result<u8> {

     

       253
       253
       +
               Ok(self.read_bytes::<{ len::INT_8 }>()?[0])

     

       254
       254
       +
           }

     

       255
       255
       +
       

     

       256
       256
       +
           fn read_u16(&mut self) -> Result<u16> {

     

       257
       257
       +
               let bytes = self.read_bytes::<{ len::INT_16 }>()?;

     

       258
       258
       +
               Ok(if self.header.little_endian {

     

       259
       259
       +
                   u16::from_le_bytes(bytes)

     

       260
       260
       +
               } else {

     

       261
       261
       +
                   u16::from_be_bytes(bytes)

     

       262
       262
       +
               })

     

       263
       263
       +
           }

     

       264
       264
       +
       

     

       265
       265
       +
           fn read_u32(&mut self) -> Result<u32> {

     

       266
       266
       +
               let bytes = self.read_bytes::<{ len::INT_32 }>()?;

     

       267
       267
       +
               Ok(if self.header.little_endian {

     

       268
       268
       +
                   u32::from_le_bytes(bytes)

     

       269
       269
       +
               } else {

     

       270
       270
       +
                   u32::from_be_bytes(bytes)

     

       271
       271
       +
               })

     

       272
       272
       +
           }

     

       273
       273
       +
       

     

       274
       274
       +
           fn read_u64(&mut self) -> Result<u64> {

     

       275
       275
       +
               let bytes = self.read_bytes::<{ len::INT_64 }>()?;

     

       276
       276
       +
               Ok(if self.header.little_endian {

     

       277
       277
       +
                   u64::from_le_bytes(bytes)

     

       278
       278
       +
               } else {

     

       279
       279
       +
                   u64::from_be_bytes(bytes)

     

       280
       280
       +
               })

     

       281
       281
       +
           }

     

       282
       282
       +
       

     

       283
       283
       +
           fn read_f32(&mut self) -> Result<f32> {

     

       284
       284
       +
               let bytes = self.read_bytes::<{ len::FLOAT_32 }>()?;

     

       285
       285
       +
               Ok(if self.header.little_endian {

     

       286
       286
       +
                   f32::from_le_bytes(bytes)

     

       287
       287
       +
               } else {

     

       288
       288
       +
                   f32::from_be_bytes(bytes)

     

       289
       289
       +
               })

     

       290
       290
       +
           }

     

       291
       291
       +
       

     

       292
       292
       +
           fn read_f64(&mut self) -> Result<f64> {

     

       293
       293
       +
               let bytes = self.read_bytes::<{ len::FLOAT_64 }>()?;

     

       294
       294
       +
               Ok(if self.header.little_endian {

     

       295
       295
       +
                   f64::from_le_bytes(bytes)

     

       296
       296
       +
               } else {

     

       297
       297
       +
                   f64::from_be_bytes(bytes)

     

       298
       298
       +
               })

     

       299
       299
       +
           }

     

       300
       300
       +
       

     

       301
       301
       +
           fn read_i8(&mut self) -> Result<i8> {

     

       302
       302
       +
               Ok(self.read_u8()? as i8)

     

       303
       303
       +
           }

     

       304
       304
       +
       

     

       305
       305
       +
           fn read_i16(&mut self) -> Result<i16> {

     

       306
       306
       +
               Ok(self.read_u16()? as i16)

     

       307
       307
       +
           }

     

       308
       308
       +
       

     

       309
       309
       +
           fn read_i32(&mut self) -> Result<i32> {

     

       310
       310
       +
               Ok(self.read_u32()? as i32)

     

       311
       311
       +
           }

     

       312
       312
       +
       

     

       313
       313
       +
           fn read_i64(&mut self) -> Result<i64> {

     

       314
       314
       +
               Ok(self.read_u64()? as i64)

     

       315
       315
       +
           }

     

       316
       316
       +
       

     

       317
       317
       +
           fn read_string(&mut self) -> Result<String> {

     

       318
       318
       +
               let length = self.read_u32()? as usize;

     

       319
       319
       +
               let bytes = self.read_bytes_vec(length)?;

     

       320
       320
       +
               String::from_utf8(bytes).map_err(Error::InvalidUtf8)

     

       321
       321
       +
           }

     

       322
       322
       +
       }

+309

src/writer.rs

···

       1
       1
       +
       use crate::{CompressionMethod, Error, FileHeader, Result, Tag, TagKind, len};

     

       2
       2
       +
       use std::io::{Seek, Write};

     

       3
       3
       +
       

     

       4
       4
       +
       use chrono::{DateTime, Utc};

     

       5
       5
       +
       use uuid::Uuid;

     

       6
       6
       +
       

     

       7
       7
       +
       struct RawWriter<W: Write + Seek> {

     

       8
       8
       +
           writer: W,

     

       9
       9
       +
           position: usize,

     

       10
       10
       +
           header: FileHeader,

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       impl<W: Write + Seek> RawWriter<W> {

     

       14
       14
       +
           fn new(writer: W, compression: CompressionMethod) -> Result<Self> {

     

       15
       15
       +
               let header = FileHeader {

     

       16
       16
       +
                   version: FileHeader::CURRENT_VERSION,

     

       17
       17
       +
                   little_endian: true,

     

       18
       18
       +
                   compression,

     

       19
       19
       +
                   payload_length: 0,

     

       20
       20
       +
               };

     

       21
       21
       +
       

     

       22
       22
       +
               Ok(Self {

     

       23
       23
       +
                   writer,

     

       24
       24
       +
                   position: 0,

     

       25
       25
       +
                   header,

     

       26
       26
       +
               })

     

       27
       27
       +
           }

     

       28
       28
       +
       

     

       29
       29
       +
           fn write_tag(&mut self, tag: &Tag) -> Result<()> {

     

       30
       30
       +
               self.write_tag_kind(tag.kind())?;

     

       31
       31
       +
               self.write_tag_of_kind(tag)?;

     

       32
       32
       +
       

     

       33
       33
       +
               self.header.payload_length = self.position as u32;

     

       34
       34
       +
       

     

       35
       35
       +
               Ok(())

     

       36
       36
       +
           }

     

       37
       37
       +
       

     

       38
       38
       +
           fn write_tag_kind(&mut self, kind: TagKind) -> Result<()> {

     

       39
       39
       +
               self.write_u8(kind as u8)

     

       40
       40
       +
           }

     

       41
       41
       +
       

     

       42
       42
       +
           fn write_tag_of_kind(&mut self, tag: &Tag) -> Result<()> {

     

       43
       43
       +
               match tag {

     

       44
       44
       +
                   Tag::U8(v) => self.write_u8(*v),

     

       45
       45
       +
                   Tag::I8(v) => self.write_i8(*v),

     

       46
       46
       +
                   Tag::U16(v) => self.write_u16(*v),

     

       47
       47
       +
                   Tag::I16(v) => self.write_i16(*v),

     

       48
       48
       +
                   Tag::U32(v) => self.write_u32(*v),

     

       49
       49
       +
                   Tag::I32(v) => self.write_i32(*v),

     

       50
       50
       +
                   Tag::U64(v) => self.write_u64(*v),

     

       51
       51
       +
                   Tag::I64(v) => self.write_i64(*v),

     

       52
       52
       +
                   Tag::F32(v) => self.write_f32(*v),

     

       53
       53
       +
                   Tag::F64(v) => self.write_f64(*v),

     

       54
       54
       +
                   Tag::Bool(v) => self.write_bool(*v),

     

       55
       55
       +
                   Tag::String(s) => self.write_string(s),

     

       56
       56
       +
                   Tag::Option(kind, opt) => self.write_option(kind, opt.as_deref()),

     

       57
       57
       +
                   Tag::List(list) => self.write_list(list),

     

       58
       58
       +
                   Tag::Array(kind, array) => self.write_array(*kind, array),

     

       59
       59
       +
                   Tag::Map(map) => self.write_map(map),

     

       60
       60
       +
                   Tag::Timestamp(dt) => self.write_timestamp(dt),

     

       61
       61
       +
                   Tag::Uuid(uuid) => self.write_uuid(uuid),

     

       62
       62
       +
               }

     

       63
       63
       +
           }

     

       64
       64
       +
       

     

       65
       65
       +
           fn write_u8(&mut self, v: u8) -> Result<()> {

     

       66
       66
       +
               self.writer.write_all(&[v]).map_err(Error::IoError)?;

     

       67
       67
       +
               self.position += len::INT_8;

     

       68
       68
       +
               Ok(())

     

       69
       69
       +
           }

     

       70
       70
       +
       

     

       71
       71
       +
           fn write_i8(&mut self, v: i8) -> Result<()> {

     

       72
       72
       +
               self.write_u8(v as u8)

     

       73
       73
       +
           }

     

       74
       74
       +
       

     

       75
       75
       +
           fn write_u16(&mut self, v: u16) -> Result<()> {

     

       76
       76
       +
               let bytes = if self.header.little_endian {

     

       77
       77
       +
                   v.to_le_bytes()

     

       78
       78
       +
               } else {

     

       79
       79
       +
                   v.to_be_bytes()

     

       80
       80
       +
               };

     

       81
       81
       +
               self.writer.write_all(&bytes).map_err(Error::IoError)?;

     

       82
       82
       +
               self.position += len::INT_16;

     

       83
       83
       +
               Ok(())

     

       84
       84
       +
           }

     

       85
       85
       +
       

     

       86
       86
       +
           fn write_i16(&mut self, v: i16) -> Result<()> {

     

       87
       87
       +
               self.write_u16(v as u16)

     

       88
       88
       +
           }

     

       89
       89
       +
       

     

       90
       90
       +
           fn write_u32(&mut self, v: u32) -> Result<()> {

     

       91
       91
       +
               let bytes = if self.header.little_endian {

     

       92
       92
       +
                   v.to_le_bytes()

     

       93
       93
       +
               } else {

     

       94
       94
       +
                   v.to_be_bytes()

     

       95
       95
       +
               };

     

       96
       96
       +
               self.writer.write_all(&bytes).map_err(Error::IoError)?;

     

       97
       97
       +
               self.position += len::INT_32;

     

       98
       98
       +
               Ok(())

     

       99
       99
       +
           }

     

       100
       100
       +
       

     

       101
       101
       +
           fn write_i32(&mut self, v: i32) -> Result<()> {

     

       102
       102
       +
               self.write_u32(v as u32)

     

       103
       103
       +
           }

     

       104
       104
       +
       

     

       105
       105
       +
           fn write_u64(&mut self, v: u64) -> Result<()> {

     

       106
       106
       +
               let bytes = if self.header.little_endian {

     

       107
       107
       +
                   v.to_le_bytes()

     

       108
       108
       +
               } else {

     

       109
       109
       +
                   v.to_be_bytes()

     

       110
       110
       +
               };

     

       111
       111
       +
               self.writer.write_all(&bytes).map_err(Error::IoError)?;

     

       112
       112
       +
               self.position += len::INT_64;

     

       113
       113
       +
               Ok(())

     

       114
       114
       +
           }

     

       115
       115
       +
       

     

       116
       116
       +
           fn write_i64(&mut self, v: i64) -> Result<()> {

     

       117
       117
       +
               self.write_u64(v as u64)

     

       118
       118
       +
           }

     

       119
       119
       +
       

     

       120
       120
       +
           fn write_f32(&mut self, v: f32) -> Result<()> {

     

       121
       121
       +
               self.write_u32(v.to_bits())

     

       122
       122
       +
           }

     

       123
       123
       +
       

     

       124
       124
       +
           fn write_f64(&mut self, v: f64) -> Result<()> {

     

       125
       125
       +
               self.write_u64(v.to_bits())

     

       126
       126
       +
           }

     

       127
       127
       +
       

     

       128
       128
       +
           fn write_bool(&mut self, v: bool) -> Result<()> {

     

       129
       129
       +
               self.write_u8(if v { 1 } else { 0 })

     

       130
       130
       +
           }

     

       131
       131
       +
       

     

       132
       132
       +
           fn write_string(&mut self, s: &str) -> Result<()> {

     

       133
       133
       +
               self.write_u32(s.len() as u32)?;

     

       134
       134
       +
               self.writer

     

       135
       135
       +
                   .write_all(s.as_bytes())

     

       136
       136
       +
                   .map_err(Error::IoError)?;

     

       137
       137
       +
               self.position += s.len();

     

       138
       138
       +
               Ok(())

     

       139
       139
       +
           }

     

       140
       140
       +
       

     

       141
       141
       +
           fn write_option(

     

       142
       142
       +
               &mut self,

     

       143
       143
       +
               kind: &TagKind,

     

       144
       144
       +
               value: Option<&Tag>,

     

       145
       145
       +
           ) -> Result<()> {

     

       146
       146
       +
               self.write_tag_kind(*kind)?;

     

       147
       147
       +
               match value {

     

       148
       148
       +
                   Some(tag) => {

     

       149
       149
       +
                       self.write_bool(true)?;

     

       150
       150
       +
                       self.write_tag_of_kind(tag)

     

       151
       151
       +
                   }

     

       152
       152
       +
                   None => self.write_bool(false),

     

       153
       153
       +
               }

     

       154
       154
       +
           }

     

       155
       155
       +
       

     

       156
       156
       +
           fn write_list(&mut self, list: &[Tag]) -> Result<()> {

     

       157
       157
       +
               self.write_u32(list.len() as u32)?;

     

       158
       158
       +
               for tag in list {

     

       159
       159
       +
                   self.write_tag(tag)?;

     

       160
       160
       +
               }

     

       161
       161
       +
               Ok(())

     

       162
       162
       +
           }

     

       163
       163
       +
       

     

       164
       164
       +
           fn write_array(&mut self, kind: TagKind, array: &[Tag]) -> Result<()> {

     

       165
       165
       +
               self.write_u32(array.len() as u32)?;

     

       166
       166
       +
               self.write_tag_kind(kind)?;

     

       167
       167
       +
               for tag in array {

     

       168
       168
       +
                   self.write_tag_of_kind(tag)?;

     

       169
       169
       +
               }

     

       170
       170
       +
               Ok(())

     

       171
       171
       +
           }

     

       172
       172
       +
       

     

       173
       173
       +
           fn write_map(&mut self, map: &[(Tag, Tag)]) -> Result<()> {

     

       174
       174
       +
               self.write_u32(map.len() as u32)?;

     

       175
       175
       +
               for (key, value) in map {

     

       176
       176
       +
                   self.write_tag(key)?;

     

       177
       177
       +
                   self.write_tag(value)?;

     

       178
       178
       +
               }

     

       179
       179
       +
               Ok(())

     

       180
       180
       +
           }

     

       181
       181
       +
       

     

       182
       182
       +
           fn write_timestamp(&mut self, dt: &DateTime<Utc>) -> Result<()> {

     

       183
       183
       +
               let timestamp = dt.timestamp_millis();

     

       184
       184
       +
               self.write_i64(timestamp)

     

       185
       185
       +
           }

     

       186
       186
       +
       

     

       187
       187
       +
           fn write_uuid(&mut self, uuid: &Uuid) -> Result<()> {

     

       188
       188
       +
               self.writer

     

       189
       189
       +
                   .write_all(uuid.as_bytes())

     

       190
       190
       +
                   .map_err(Error::IoError)?;

     

       191
       191
       +
               self.position += len::UUID;

     

       192
       192
       +
               Ok(())

     

       193
       193
       +
           }

     

       194
       194
       +
       }

     

       195
       195
       +
       

     

       196
       196
       +
       pub struct Writer<W: Write> {

     

       197
       197
       +
           inner: W,

     

       198
       198
       +
           raw_writer: RawWriter<std::io::Cursor<Vec<u8>>>,

     

       199
       199
       +
           compression: CompressionMethod,

     

       200
       200
       +
       }

     

       201
       201
       +
       

     

       202
       202
       +
       impl<W: Write> Writer<W> {

     

       203
       203
       +
           pub fn new(writer: W, compression: CompressionMethod) -> Result<Self> {

     

       204
       204
       +
               let buffer = std::io::Cursor::new(Vec::new());

     

       205
       205
       +
               let raw_writer = RawWriter::new(buffer, CompressionMethod::None)?;

     

       206
       206
       +
               Ok(Self {

     

       207
       207
       +
                   inner: writer,

     

       208
       208
       +
                   raw_writer,

     

       209
       209
       +
                   compression,

     

       210
       210
       +
               })

     

       211
       211
       +
           }

     

       212
       212
       +
       

     

       213
       213
       +
           pub fn write_tag(&mut self, tag: &Tag) -> Result<()> {

     

       214
       214
       +
               self.raw_writer.write_tag(tag)

     

       215
       215
       +
           }

     

       216
       216
       +
       

     

       217
       217
       +
           pub fn finish(mut self) -> Result<W> {

     

       218
       218
       +
               let uncompressed = self.raw_writer.writer.into_inner();

     

       219
       219
       +
               let compressed = match self.compression {

     

       220
       220
       +
                   CompressionMethod::None => uncompressed.clone(),

     

       221
       221
       +
                   CompressionMethod::Gzip => {

     

       222
       222
       +
                       #[cfg(feature = "gzip")]

     

       223
       223
       +
                       {

     

       224
       224
       +
                           let mut encoder = flate2::GzBuilder::new()

     

       225
       225
       +
                               .mtime(0)

     

       226
       226
       +
                               .operating_system(0)

     

       227
       227
       +
                               .write(Vec::new(), flate2::Compression::fast());

     

       228
       228
       +
                           encoder.write_all(&uncompressed).map_err(Error::IoError)?;

     

       229
       229
       +
                           encoder.finish().map_err(Error::IoError)?

     

       230
       230
       +
                       }

     

       231
       231
       +
                       #[cfg(not(feature = "gzip"))]

     

       232
       232
       +
                       {

     

       233
       233
       +
                           return Err(Error::UnsupportedCompression(

     

       234
       234
       +
                               self.compression,

     

       235
       235
       +
                           ));

     

       236
       236
       +
                       }

     

       237
       237
       +
                   }

     

       238
       238
       +
                   CompressionMethod::Zlib => {

     

       239
       239
       +
                       #[cfg(feature = "gzip")]

     

       240
       240
       +
                       {

     

       241
       241
       +
                           let mut encoder = flate2::write::ZlibEncoder::new(

     

       242
       242
       +
                               Vec::new(),

     

       243
       243
       +
                               flate2::Compression::default(),

     

       244
       244
       +
                           );

     

       245
       245
       +
                           encoder.write_all(&uncompressed).map_err(Error::IoError)?;

     

       246
       246
       +
                           encoder.finish().map_err(Error::IoError)?

     

       247
       247
       +
                       }

     

       248
       248
       +
                       #[cfg(not(feature = "gzip"))]

     

       249
       249
       +
                       {

     

       250
       250
       +
                           return Err(Error::UnsupportedCompression(

     

       251
       251
       +
                               self.compression,

     

       252
       252
       +
                           ));

     

       253
       253
       +
                       }

     

       254
       254
       +
                   }

     

       255
       255
       +
                   CompressionMethod::Lz4 => {

     

       256
       256
       +
                       #[cfg(feature = "lz4")]

     

       257
       257
       +
                       {

     

       258
       258
       +
                           let mut encoder = lz4::EncoderBuilder::new()

     

       259
       259
       +
                               .level(4)

     

       260
       260
       +
                               .build(Vec::new())

     

       261
       261
       +
                               .map_err(Error::IoError)?;

     

       262
       262
       +
                           encoder.write_all(&uncompressed).map_err(Error::IoError)?;

     

       263
       263
       +
                           let (compressed, _) = encoder.finish();

     

       264
       264
       +
                           compressed

     

       265
       265
       +
                       }

     

       266
       266
       +
                       #[cfg(not(feature = "lz4"))]

     

       267
       267
       +
                       {

     

       268
       268
       +
                           return Err(Error::UnsupportedCompression(

     

       269
       269
       +
                               self.compression,

     

       270
       270
       +
                           ));

     

       271
       271
       +
                       }

     

       272
       272
       +
                   }

     

       273
       273
       +
               };

     

       274
       274
       +
       

     

       275
       275
       +
               let header = FileHeader {

     

       276
       276
       +
                   version: FileHeader::CURRENT_VERSION,

     

       277
       277
       +
                   little_endian: true,

     

       278
       278
       +
                   compression: self.compression,

     

       279
       279
       +
                   payload_length: compressed.len() as u32,

     

       280
       280
       +
               };

     

       281
       281
       +
       

     

       282
       282
       +
               // write header

     

       283
       283
       +
               self.inner

     

       284
       284
       +
                   .write_all(&FileHeader::MAGIC_BYTES)

     

       285
       285
       +
                   .map_err(Error::IoError)?;

     

       286
       286
       +
               self.inner

     

       287
       287
       +
                   .write_all(&[header.version])

     

       288
       288
       +
                   .map_err(Error::IoError)?;

     

       289
       289
       +
               self.inner

     

       290
       290
       +
                   .write_all(&[!header.little_endian as u8])

     

       291
       291
       +
                   .map_err(Error::IoError)?;

     

       292
       292
       +
               self.inner

     

       293
       293
       +
                   .write_all(&[header.compression as u8])

     

       294
       294
       +
                   .map_err(Error::IoError)?;

     

       295
       295
       +
               let payload_bytes = if header.little_endian {

     

       296
       296
       +
                   header.payload_length.to_le_bytes()

     

       297
       297
       +
               } else {

     

       298
       298
       +
                   header.payload_length.to_be_bytes()

     

       299
       299
       +
               };

     

       300
       300
       +
               self.inner

     

       301
       301
       +
                   .write_all(&payload_bytes)

     

       302
       302
       +
                   .map_err(Error::IoError)?;

     

       303
       303
       +
       

     

       304
       304
       +
               // write payload

     

       305
       305
       +
               self.inner.write_all(&compressed).map_err(Error::IoError)?;

     

       306
       306
       +
       

     

       307
       307
       +
               Ok(self.inner)

     

       308
       308
       +
           }

     

       309
       309
       +
       }

tests/fixtures/hello_world.nbt2

This is a binary file and will not be displayed.

+16

tests/snapshots/test_io__read_hello_world-2.snap

···

       1
       1
       +
       ---

     

       2
       2
       +
       source: tests/test_io.rs

     

       3
       3
       +
       expression: hello_world

     

       4
       4
       +
       ---

     

       5
       5
       +
       Map(

     

       6
       6
       +
           [

     

       7
       7
       +
               (

     

       8
       8
       +
                   String(

     

       9
       9
       +
                       "message",

     

       10
       10
       +
                   ),

     

       11
       11
       +
                   String(

     

       12
       12
       +
                       "Hello World",

     

       13
       13
       +
                   ),

     

       14
       14
       +
               ),

     

       15
       15
       +
           ],

     

       16
       16
       +
       )

+10

tests/snapshots/test_io__read_hello_world.snap

···

       1
       1
       +
       ---

     

       2
       2
       +
       source: tests/test_io.rs

     

       3
       3
       +
       expression: reader.file_header()

     

       4
       4
       +
       ---

     

       5
       5
       +
       FileHeader {

     

       6
       6
       +
           version: 1,

     

       7
       7
       +
           little_endian: true,

     

       8
       8
       +
           compression: None,

     

       9
       9
       +
           payload_length: 33,

     

       10
       10
       +
       }

+91

tests/tags/mod.rs

···

       1
       1
       +
       use std::{f32, f64, i8, i16, u8, u16};

     

       2
       2
       +
       

     

       3
       3
       +
       use chrono::DateTime;

     

       4
       4
       +
       use nbt2::{Tag, TagKind};

     

       5
       5
       +
       use uuid::Uuid;

     

       6
       6
       +
       

     

       7
       7
       +
       pub const HELLO_WORLD_BYTES: &[u8] =

     

       8
       8
       +
           include_bytes!("../fixtures/hello_world.nbt2");

     

       9
       9
       +
       

     

       10
       10
       +
       pub fn hello_world() -> Tag {

     

       11
       11
       +
           Tag::new_map(vec![(

     

       12
       12
       +
               Tag::new_string("message"),

     

       13
       13
       +
               Tag::new_string("Hello World"),

     

       14
       14
       +
           )])

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       pub fn bigtest() -> Tag {

     

       18
       18
       +
           Tag::new_map(vec![

     

       19
       19
       +
               (Tag::new_string("a u8"), Tag::new_u8(u8::MAX)),

     

       20
       20
       +
               (Tag::new_string("an i8"), Tag::new_i8(i8::MIN)),

     

       21
       21
       +
               (Tag::new_string("a u16"), Tag::new_u16(u16::MAX)),

     

       22
       22
       +
               (Tag::new_string("an i16"), Tag::new_i16(i16::MIN)),

     

       23
       23
       +
               (Tag::new_string("a u32"), Tag::new_u32(u32::MAX)),

     

       24
       24
       +
               (Tag::new_string("an i32"), Tag::new_i32(i32::MIN)),

     

       25
       25
       +
               (Tag::new_string("a u64"), Tag::new_u64(u64::MAX)),

     

       26
       26
       +
               (Tag::new_string("an i64"), Tag::new_i64(i64::MIN)),

     

       27
       27
       +
               (Tag::new_string("an f32"), Tag::new_f32(f32::consts::PI)),

     

       28
       28
       +
               (Tag::new_string("an f64"), Tag::new_f64(f64::consts::PI)),

     

       29
       29
       +
               (Tag::new_string("a boolean (true)"), Tag::new_bool(true)),

     

       30
       30
       +
               (Tag::new_string("a boolean (false)"), Tag::new_bool(false)),

     

       31
       31
       +
               (

     

       32
       32
       +
                   Tag::new_string("a string"),

     

       33
       33
       +
                   Tag::new_string("hello, world!"),

     

       34
       34
       +
               ),

     

       35
       35
       +
               (

     

       36
       36
       +
                   Tag::new_string("an optional value"),

     

       37
       37
       +
                   Tag::new_option(TagKind::F64, Some(Tag::new_f64(f64::consts::TAU))),

     

       38
       38
       +
               ),

     

       39
       39
       +
               (

     

       40
       40
       +
                   Tag::new_string("a list"),

     

       41
       41
       +
                   Tag::new_list(vec![

     

       42
       42
       +
                       Tag::new_string("hello"),

     

       43
       43
       +
                       Tag::new_u8(42),

     

       44
       44
       +
                       Tag::new_bool(true),

     

       45
       45
       +
                   ]),

     

       46
       46
       +
               ),

     

       47
       47
       +
               (

     

       48
       48
       +
                   Tag::new_string("a map where keys are u8.. except one!"),

     

       49
       49
       +
                   Tag::new_map(vec![

     

       50
       50
       +
                       (Tag::new_u8(42), Tag::new_string("the meaning of life")),

     

       51
       51
       +
                       (Tag::new_u8(69), Tag::new_string("the funny number")),

     

       52
       52
       +
                       (

     

       53
       53
       +
                           Tag::new_string("boo!"),

     

       54
       54
       +
                           Tag::new_map(vec![(

     

       55
       55
       +
                               Tag::new_string("is_scared"),

     

       56
       56
       +
                               Tag::new_bool(true),

     

       57
       57
       +
                           )]),

     

       58
       58
       +
                       ),

     

       59
       59
       +
                       (Tag::new_u8(u8::MAX), Tag::new_string("the maximum")),

     

       60
       60
       +
                   ]),

     

       61
       61
       +
               ),

     

       62
       62
       +
               (

     

       63
       63
       +
                   Tag::new_string("an array of booleans"),

     

       64
       64
       +
                   Tag::new_array(

     

       65
       65
       +
                       TagKind::Bool,

     

       66
       66
       +
                       vec![

     

       67
       67
       +
                           Tag::new_bool(true),

     

       68
       68
       +
                           Tag::new_bool(true),

     

       69
       69
       +
                           Tag::new_bool(true),

     

       70
       70
       +
                           Tag::new_bool(false),

     

       71
       71
       +
                           Tag::new_bool(true),

     

       72
       72
       +
                           Tag::new_bool(true),

     

       73
       73
       +
                           Tag::new_bool(true),

     

       74
       74
       +
                       ],

     

       75
       75
       +
                   ),

     

       76
       76
       +
               ),

     

       77
       77
       +
               (

     

       78
       78
       +
                   Tag::new_string("the time im making this file"),

     

       79
       79
       +
                   Tag::new_timestamp(

     

       80
       80
       +
                       DateTime::from_timestamp_millis(1755598018230).unwrap(),

     

       81
       81
       +
                   ),

     

       82
       82
       +
               ),

     

       83
       83
       +
               (

     

       84
       84
       +
                   Tag::new_string("my minecraft account's uuid"),

     

       85
       85
       +
                   Tag::new_uuid(

     

       86
       86
       +
                       Uuid::parse_str("89c29c53-ef0c-4623-92cb-0f79930a97c2")

     

       87
       87
       +
                           .unwrap(),

     

       88
       88
       +
                   ),

     

       89
       89
       +
               ),

     

       90
       90
       +
           ])

     

       91
       91
       +
       }

+61

tests/test_io.rs

···

       1
       1
       +
       mod tags;

     

       2
       2
       +
       

     

       3
       3
       +
       use std::io::Cursor;

     

       4
       4
       +
       

     

       5
       5
       +
       use insta::assert_debug_snapshot;

     

       6
       6
       +
       use nbt2::{CompressionMethod, reader::Reader, writer::Writer};

     

       7
       7
       +
       

     

       8
       8
       +
       #[test]

     

       9
       9
       +
       fn test_read_hello_world() {

     

       10
       10
       +
           let mut reader = Reader::new(Cursor::new(tags::HELLO_WORLD_BYTES)).unwrap();

     

       11
       11
       +
       

     

       12
       12
       +
           assert_debug_snapshot!(reader.file_header());

     

       13
       13
       +
       

     

       14
       14
       +
           let hello_world = reader.read_tag().unwrap();

     

       15
       15
       +
       

     

       16
       16
       +
           assert_debug_snapshot!(hello_world);

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       #[test]

     

       20
       20
       +
       fn test_write_hello_world() {

     

       21
       21
       +
           let bytes: Vec<u8> = {

     

       22
       22
       +
               let mut writer =

     

       23
       23
       +
                   Writer::new(Vec::new(), CompressionMethod::None).unwrap();

     

       24
       24
       +
               writer.write_tag(&tags::hello_world()).unwrap();

     

       25
       25
       +
               writer.finish().unwrap()

     

       26
       26
       +
           };

     

       27
       27
       +
       

     

       28
       28
       +
           assert_eq!(tags::HELLO_WORLD_BYTES, bytes.as_slice())

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[inline(always)]

     

       32
       32
       +
       fn test_round_trip_bt(compression: CompressionMethod) {

     

       33
       33
       +
           let bytes: Vec<u8> = {

     

       34
       34
       +
               let mut writer = Writer::new(Vec::new(), compression).unwrap();

     

       35
       35
       +
               writer.write_tag(&tags::bigtest()).unwrap();

     

       36
       36
       +
               writer.finish().unwrap()

     

       37
       37
       +
           };

     

       38
       38
       +
           let read_tag = Reader::new(Cursor::new(bytes)).unwrap().read_tag().unwrap();

     

       39
       39
       +
       

     

       40
       40
       +
           assert_eq!(tags::bigtest(), read_tag, "compression: {:?}", compression);

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       #[test]

     

       44
       44
       +
       fn test_wr_round_trip_bt_none() {

     

       45
       45
       +
           test_round_trip_bt(CompressionMethod::None);

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       #[test]

     

       49
       49
       +
       fn test_wr_round_trip_bt_gzip() {

     

       50
       50
       +
           test_round_trip_bt(CompressionMethod::Gzip);

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       #[test]

     

       54
       54
       +
       fn test_wr_round_trip_bt_zlib() {

     

       55
       55
       +
           test_round_trip_bt(CompressionMethod::Zlib);

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       #[test]

     

       59
       59
       +
       fn test_wr_round_trip_bt_lz4() {

     

       60
       60
       +
           test_round_trip_bt(CompressionMethod::Lz4);

     

       61
       61
       +
       }