cborg 1.6.1 → 1.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (28) hide show
  1. package/README.md +108 -11
  2. package/cjs/browser-test/node-test-bin.js +232 -105
  3. package/cjs/lib/3string.js +12 -8
  4. package/cjs/lib/bin.js +39 -23
  5. package/cjs/lib/diagnostic.js +57 -18
  6. package/cjs/lib/token.js +1 -0
  7. package/cjs/node-test/node-test-bin.js +232 -105
  8. package/esm/browser-test/node-test-bin.js +232 -105
  9. package/esm/lib/3string.js +16 -9
  10. package/esm/lib/bin.js +43 -24
  11. package/esm/lib/diagnostic.js +62 -20
  12. package/esm/lib/token.js +1 -0
  13. package/esm/node-test/node-test-bin.js +232 -105
  14. package/interface.ts +1 -0
  15. package/lib/3string.js +15 -10
  16. package/lib/bin.js +52 -27
  17. package/lib/diagnostic.js +74 -23
  18. package/lib/token.js +2 -0
  19. package/package.json +1 -1
  20. package/test/node-test-bin.js +271 -120
  21. package/types/interface.d.ts +1 -0
  22. package/types/interface.d.ts.map +1 -1
  23. package/types/lib/3string.d.ts +2 -2
  24. package/types/lib/3string.d.ts.map +1 -1
  25. package/types/lib/diagnostic.d.ts +6 -0
  26. package/types/lib/diagnostic.d.ts.map +1 -1
  27. package/types/lib/token.d.ts +2 -0
  28. package/types/lib/token.d.ts.map +1 -1
package/esm/browser-test/node-test-bin.js CHANGED
@@ -2,9 +2,56 @@ import chai from 'chai';
2
2
  import { exec } from 'child_process';
3
3
  import process from 'process';
4
4
  import path from 'path';
5
+ import { platform } from 'os';
5
6
  import { fileURLToPath } from 'url';
6
7
  import bin from '../lib/bin.js';
7
8
  const {assert} = chai;
9
+ const fixture1JsonString = '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}';
10
+ const fixture1JsonPrettyString = `{
11
+ "a": 1,
12
+ "b": [
13
+ 2,
14
+ 3
15
+ ],
16
+ "smile": "😀"
17
+ }
18
+ `;
19
+ const fixture1HexString = 'a3616101616282020365736d696c6564f09f9880';
20
+ const fixture1Bin = fromHex(fixture1HexString);
21
+ const fixture1BinString = new TextDecoder().decode(fixture1Bin);
22
+ const fixture1DiagnosticString = `a3 # map(3)
23
+ 61 # string(1)
24
+ 61 # "a"
25
+ 01 # uint(1)
26
+ 61 # string(1)
27
+ 62 # "b"
28
+ 82 # array(2)
29
+ 02 # uint(2)
30
+ 03 # uint(3)
31
+ 65 # string(5)
32
+ 736d696c65 # "smile"
33
+ 64 # string(2)
34
+ f09f9880 # "😀"
35
+ `;
36
+ const fixture2HexString = 'a4616101616282020363627566440102036165736d696c6564f09f9880';
37
+ const fixture2DiagnosticString = `a4 # map(4)
38
+ 61 # string(1)
39
+ 61 # "a"
40
+ 01 # uint(1)
41
+ 61 # string(1)
42
+ 62 # "b"
43
+ 82 # array(2)
44
+ 02 # uint(2)
45
+ 03 # uint(3)
46
+ 63 # string(3)
47
+ 627566 # "buf"
48
+ 44 # bytes(4)
49
+ 01020361 # "\\x01\\x02\\x03a"
50
+ 65 # string(5)
51
+ 736d696c65 # "smile"
52
+ 64 # string(2)
53
+ f09f9880 # "😀"
54
+ `;
8
55
  const binPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '../lib/bin.js');
9
56
  function fromHex(hex) {
10
57
  return new Uint8Array(hex.split('').map((c, i, d) => i % 2 === 0 ? `0x${ c }${ d[i + 1] }` : '').filter(Boolean).map(e => parseInt(e, 16)));
@@ -39,15 +86,18 @@ describe('Bin', () => {
39
86
  assert.strictEqual(e.stdout, '');
40
87
  assert.strictEqual(e.stderr, `Usage: cborg <command> <args>
41
88
  Valid commands:
42
- \thex2diag [hex input]
43
- \thex2bin [hex input]
44
- \thex2json [--pretty] [hex input]
45
- \tbin2hex [binary input]
46
89
  \tbin2diag [binary input]
90
+ \tbin2hex [binary input]
47
91
  \tbin2json [--pretty] [binary input]
48
- \tjson2hex '[json input]'
49
- \tjson2diag '[json input]'
92
+ \tdiag2bin [diagnostic input]
93
+ \tdiag2hex [diagnostic input]
94
+ \tdiag2json [--pretty] [diagnostic input]
95
+ \thex2bin [hex input]
96
+ \thex2diag [hex input]
97
+ \thex2json [--pretty] [hex input]
50
98
  \tjson2bin '[json input]'
99
+ \tjson2diag '[json input]'
100
+ \tjson2hex '[json input]'
51
101
  Input may either be supplied as an argument or piped via stdin
52
102
  `);
53
103
  }
@@ -61,15 +111,18 @@ Input may either be supplied as an argument or piped via stdin
61
111
  assert.strictEqual(e.stderr, `Unknown command: 'blip'
62
112
  Usage: cborg <command> <args>
63
113
  Valid commands:
64
- \thex2diag [hex input]
65
- \thex2bin [hex input]
66
- \thex2json [--pretty] [hex input]
67
- \tbin2hex [binary input]
68
114
  \tbin2diag [binary input]
115
+ \tbin2hex [binary input]
69
116
  \tbin2json [--pretty] [binary input]
70
- \tjson2hex '[json input]'
71
- \tjson2diag '[json input]'
117
+ \tdiag2bin [diagnostic input]
118
+ \tdiag2hex [diagnostic input]
119
+ \tdiag2json [--pretty] [diagnostic input]
120
+ \thex2bin [hex input]
121
+ \thex2diag [hex input]
122
+ \thex2json [--pretty] [hex input]
72
123
  \tjson2bin '[json input]'
124
+ \tjson2diag '[json input]'
125
+ \tjson2hex '[json input]'
73
126
  Input may either be supplied as an argument or piped via stdin
74
127
  `);
75
128
  }
@@ -79,135 +132,209 @@ Input may either be supplied as an argument or piped via stdin
79
132
  assert.strictEqual(stdout, '');
80
133
  assert.strictEqual(stderr, `Usage: cborg <command> <args>
81
134
  Valid commands:
82
- \thex2diag [hex input]
83
- \thex2bin [hex input]
84
- \thex2json [--pretty] [hex input]
85
- \tbin2hex [binary input]
86
135
  \tbin2diag [binary input]
136
+ \tbin2hex [binary input]
87
137
  \tbin2json [--pretty] [binary input]
88
- \tjson2hex '[json input]'
89
- \tjson2diag '[json input]'
138
+ \tdiag2bin [diagnostic input]
139
+ \tdiag2hex [diagnostic input]
140
+ \tdiag2json [--pretty] [diagnostic input]
141
+ \thex2bin [hex input]
142
+ \thex2diag [hex input]
143
+ \thex2json [--pretty] [hex input]
90
144
  \tjson2bin '[json input]'
145
+ \tjson2diag '[json input]'
146
+ \tjson2hex '[json input]'
91
147
  Input may either be supplied as an argument or piped via stdin
92
148
  `);
93
149
  });
150
+ it('bin2diag (stdin)', async () => {
151
+ const {stdout, stderr} = await execBin('bin2diag', fixture1Bin);
152
+ assert.strictEqual(stderr, '');
153
+ assert.strictEqual(stdout, fixture1DiagnosticString);
154
+ });
155
+ it('bin2hex (stdin)', async () => {
156
+ const {stdout, stderr} = await execBin('bin2hex', fixture1Bin);
157
+ assert.strictEqual(stderr, '');
158
+ assert.strictEqual(stdout, `${ fixture1HexString }\n`);
159
+ });
160
+ it('bin2json (stdin)', async () => {
161
+ const {stdout, stderr} = await execBin('bin2json', fixture1Bin);
162
+ assert.strictEqual(stderr, '');
163
+ assert.strictEqual(stdout, `${ fixture1JsonString }\n`);
164
+ });
165
+ it('bin2json pretty (stdin)', async () => {
166
+ const {stdout, stderr} = await execBin('bin2json --pretty', fixture1Bin);
167
+ assert.strictEqual(stderr, '');
168
+ assert.strictEqual(stdout, fixture1JsonPrettyString);
169
+ });
94
170
  for (const stdin of [
95
171
  true,
96
172
  false
97
173
  ]) {
98
- it(`hex2json${ stdin ? ' (stdin)' : '' }`, async () => {
99
- const {stdout, stderr} = stdin ? await execBin('hex2json a3616101616282020365736d696c6564f09f9880') : await execBin('hex2json', 'a3616101616282020365736d696c6564f09f9880');
100
- assert.strictEqual(stderr, '');
101
- assert.strictEqual(stdout, '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}\n');
102
- });
103
- it(`hex2json pretty${ stdin ? ' (stdin)' : '' }`, async () => {
104
- const {stdout, stderr} = stdin ? await execBin('hex2json --pretty a3616101616282020365736d696c6564f09f9880') : await execBin('hex2json --pretty', 'a3616101616282020365736d696c6564f09f9880');
174
+ if (platform() !== 'win32' || stdin) {
175
+ it(`diag2bin${ stdin ? ' (stdin)' : '' }`, async () => {
176
+ const {stdout, stderr} = !stdin ? await execBin(`diag2bin '${ fixture1DiagnosticString }'`) : await execBin('diag2bin', fixture1DiagnosticString);
177
+ assert.strictEqual(stderr, '');
178
+ assert.strictEqual(stdout, fixture1BinString);
179
+ });
180
+ it(`diag2hex${ stdin ? ' (stdin)' : '' }`, async () => {
181
+ const {stdout, stderr} = !stdin ? await execBin(`diag2hex '${ fixture1DiagnosticString }'`) : await execBin('diag2hex', fixture1DiagnosticString);
182
+ assert.strictEqual(stderr, '');
183
+ assert.strictEqual(stdout, `${ fixture1HexString }\n`);
184
+ });
185
+ it(`diag2json${ stdin ? ' (stdin)' : '' }`, async () => {
186
+ const {stdout, stderr} = !stdin ? await execBin(`diag2json '${ fixture1DiagnosticString }'`) : await execBin('diag2json', fixture1DiagnosticString);
187
+ assert.strictEqual(stderr, '');
188
+ assert.strictEqual(stdout, `${ fixture1JsonString }\n`);
189
+ });
190
+ it(`diag2json pretty${ stdin ? ' (stdin)' : '' }`, async () => {
191
+ const {stdout, stderr} = !stdin ? await execBin(`diag2json --pretty '${ fixture1DiagnosticString }'`) : await execBin('diag2json --pretty', fixture1DiagnosticString);
192
+ assert.strictEqual(stderr, '');
193
+ assert.strictEqual(stdout, fixture1JsonPrettyString);
194
+ });
195
+ }
196
+ it(`hex2bin${ stdin ? ' (stdin)' : '' }`, async () => {
197
+ const {stdout, stderr} = !stdin ? await execBin(`hex2bin ${ fixture1HexString }`) : await execBin('hex2bin', fixture1HexString);
105
198
  assert.strictEqual(stderr, '');
106
- assert.strictEqual(stdout, `{
107
- "a": 1,
108
- "b": [
109
- 2,
110
- 3
111
- ],
112
- "smile": "😀"
113
- }
114
- `);
199
+ assert.strictEqual(stdout, fixture1BinString);
115
200
  });
116
201
  it(`hex2diag${ stdin ? ' (stdin)' : '' }`, async () => {
117
- const {stdout, stderr} = stdin ? await execBin('hex2diag a4616101616282020363627566440102036165736d696c6564f09f9880') : await execBin('hex2diag', 'a4616101616282020363627566440102036165736d696c6564f09f9880');
202
+ const {stdout, stderr} = !stdin ? await execBin(`hex2diag ${ fixture2HexString }`) : await execBin('hex2diag', fixture2HexString);
118
203
  assert.strictEqual(stderr, '');
119
- assert.strictEqual(stdout, `a4 # map(4)
120
- 61 # string(1)
121
- 61 # "a"
122
- 01 # uint(1)
123
- 61 # string(1)
124
- 62 # "b"
125
- 82 # array(2)
126
- 02 # uint(2)
127
- 03 # uint(3)
128
- 63 # string(3)
129
- 627566 # "buf"
130
- 44 # bytes(4)
131
- 01020361 # "\\x01\\x02\\x03a"
132
- 65 # string(5)
133
- 736d696c65 # "smile"
134
- 64 f09f # string(2)
135
- f09f9880 # "😀"
136
- `);
204
+ assert.strictEqual(stdout, fixture2DiagnosticString);
137
205
  });
138
- it(`hex2bin${ stdin ? ' (stdin)' : '' }`, async () => {
139
- const {stdout, stderr} = stdin ? await execBin('hex2bin a3616101616282020365736d696c6564f09f9880') : await execBin('hex2bin', 'a3616101616282020365736d696c6564f09f9880');
206
+ it(`hex2json${ stdin ? ' (stdin)' : '' }`, async () => {
207
+ const {stdout, stderr} = !stdin ? await execBin(`hex2json ${ fixture1HexString }`) : await execBin('hex2json', fixture1HexString);
140
208
  assert.strictEqual(stderr, '');
141
- assert.strictEqual(stdout, new TextDecoder().decode(fromHex('a3616101616282020365736d696c6564f09f9880')));
209
+ assert.strictEqual(stdout, `${ fixture1JsonString }\n`);
142
210
  });
143
- it(`json2hex${ stdin ? ' (stdin)' : '' }`, async () => {
144
- const {stdout, stderr} = stdin ? await execBin('json2hex "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2hex', '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}');
211
+ it(`hex2json pretty${ stdin ? ' (stdin)' : '' }`, async () => {
212
+ const {stdout, stderr} = !stdin ? await execBin(`hex2json --pretty ${ fixture1HexString }`) : await execBin('hex2json --pretty', fixture1HexString);
145
213
  assert.strictEqual(stderr, '');
146
- assert.strictEqual(stdout, 'a3616101616282020365736d696c6564f09f9880\n');
214
+ assert.strictEqual(stdout, fixture1JsonPrettyString);
147
215
  });
148
216
  it(`json2bin${ stdin ? ' (stdin)' : '' }`, async () => {
149
- const {stdout, stderr} = stdin ? await execBin('json2bin "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2bin', '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}');
217
+ const {stdout, stderr} = !stdin ? await execBin('json2bin "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2bin', fixture1JsonString);
150
218
  assert.strictEqual(stderr, '');
151
- assert.strictEqual(stdout, new TextDecoder().decode(fromHex('a3616101616282020365736d696c6564f09f9880')));
219
+ assert.strictEqual(stdout, fixture1BinString);
152
220
  });
153
221
  it(`json2diag${ stdin ? ' (stdin)' : '' }`, async () => {
154
- const {stdout, stderr} = stdin ? await execBin('json2diag "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2diag', '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}');
222
+ const {stdout, stderr} = !stdin ? await execBin('json2diag "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2diag', fixture1JsonString);
155
223
  assert.strictEqual(stderr, '');
156
- assert.strictEqual(stdout, `a3 # map(3)
157
- 61 # string(1)
158
- 61 # "a"
159
- 01 # uint(1)
160
- 61 # string(1)
161
- 62 # "b"
162
- 82 # array(2)
163
- 02 # uint(2)
164
- 03 # uint(3)
165
- 65 # string(5)
166
- 736d696c65 # "smile"
167
- 64 f09f # string(2)
168
- f09f9880 # "😀"
169
- `);
224
+ assert.strictEqual(stdout, fixture1DiagnosticString);
225
+ });
226
+ it(`json2hex${ stdin ? ' (stdin)' : '' }`, async () => {
227
+ const {stdout, stderr} = !stdin ? await execBin(`json2hex "${ fixture1JsonString.replace(/"/g, '\\"') }"`) : await execBin('json2hex', fixture1JsonString);
228
+ assert.strictEqual(stderr, '');
229
+ assert.strictEqual(stdout, `${ fixture1HexString }\n`);
170
230
  });
171
231
  }
172
- it('bin2diag (stdin)', async () => {
173
- const {stdout, stderr} = await execBin('bin2diag', fromHex('a3616101616282020365736d696c6564f09f9880'));
232
+ it('diag indenting', async () => {
233
+ const {stdout, stderr} = await execBin('json2diag', '{"a":[],"b":{},"c":{"a":1,"b":{"a":{"a":{}}}},"d":{"a":{"a":{"a":1},"b":2,"c":[]}},"e":[[[[{"a":{}}]]]],"f":1}');
174
234
  assert.strictEqual(stderr, '');
175
- assert.strictEqual(stdout, `a3 # map(3)
235
+ assert.strictEqual(stdout, `a6 # map(6)
176
236
  61 # string(1)
177
237
  61 # "a"
178
- 01 # uint(1)
238
+ 80 # array(0)
179
239
  61 # string(1)
180
240
  62 # "b"
181
- 82 # array(2)
182
- 02 # uint(2)
183
- 03 # uint(3)
184
- 65 # string(5)
185
- 736d696c65 # "smile"
186
- 64 f09f # string(2)
187
- f09f9880 # "😀"
241
+ a0 # map(0)
242
+ 61 # string(1)
243
+ 63 # "c"
244
+ a2 # map(2)
245
+ 61 # string(1)
246
+ 61 # "a"
247
+ 01 # uint(1)
248
+ 61 # string(1)
249
+ 62 # "b"
250
+ a1 # map(1)
251
+ 61 # string(1)
252
+ 61 # "a"
253
+ a1 # map(1)
254
+ 61 # string(1)
255
+ 61 # "a"
256
+ a0 # map(0)
257
+ 61 # string(1)
258
+ 64 # "d"
259
+ a1 # map(1)
260
+ 61 # string(1)
261
+ 61 # "a"
262
+ a3 # map(3)
263
+ 61 # string(1)
264
+ 61 # "a"
265
+ a1 # map(1)
266
+ 61 # string(1)
267
+ 61 # "a"
268
+ 01 # uint(1)
269
+ 61 # string(1)
270
+ 62 # "b"
271
+ 02 # uint(2)
272
+ 61 # string(1)
273
+ 63 # "c"
274
+ 80 # array(0)
275
+ 61 # string(1)
276
+ 65 # "e"
277
+ 81 # array(1)
278
+ 81 # array(1)
279
+ 81 # array(1)
280
+ 81 # array(1)
281
+ a1 # map(1)
282
+ 61 # string(1)
283
+ 61 # "a"
284
+ a0 # map(0)
285
+ 61 # string(1)
286
+ 66 # "f"
287
+ 01 # uint(1)
188
288
  `);
189
289
  });
190
- it('bin2json (stdin)', async () => {
191
- const {stdout, stderr} = await execBin('bin2json', fromHex('a3616101616282020365736d696c6564f09f9880'));
192
- assert.strictEqual(stderr, '');
193
- assert.strictEqual(stdout, '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}\n');
290
+ describe('diag length bytes', () => {
291
+ it('compact', async () => {
292
+ const {stdout, stderr} = await execBin('json2diag', '"aaaaaaaaaaaaaaaaaaaaaaa"');
293
+ assert.strictEqual(stderr, '');
294
+ assert.strictEqual(stdout, `77 # string(23)
295
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
296
+ `);
297
+ });
298
+ it('1-byte', async () => {
299
+ const {stdout, stderr} = await execBin('json2diag', '"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"');
300
+ assert.strictEqual(stderr, '');
301
+ assert.strictEqual(stdout, `78 23 # string(35)
302
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
303
+ 616161616161616161616161 # "aaaaaaaaaaaa"
304
+ `);
305
+ });
306
+ it('2-byte', async () => {
307
+ const {stdout, stderr} = await execBin('json2diag', '"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"');
308
+ assert.strictEqual(stderr, '');
309
+ assert.strictEqual(stdout, `79 0100 # string(256)
310
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
311
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
312
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
313
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
314
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
315
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
316
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
317
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
318
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
319
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
320
+ 6161616161616161616161616161616161616161616161 # "aaaaaaaaaaaaaaaaaaaaaaa"
321
+ 616161 # "aaa"
322
+ `);
323
+ });
194
324
  });
195
- it('bin2json pretty (stdin)', async () => {
196
- const {stdout, stderr} = await execBin('bin2json --pretty', fromHex('a3616101616282020365736d696c6564f09f9880'));
325
+ it('diag non-utf8 and non-printable ascii', async () => {
326
+ const input = '7864f55ff8f12508b63ef2bfeca7557ae90df6311a5ec1631b4a1fa843310bd9c3a710eaace5a1bdd72ad0bfe049771c11e756338bd93865e645f1adec9b9c99ef407fbd4fc6859e7904c5ad7dc9bd10a5cc16973d5b28ec1a6dd43d9f82f9f18c3d03418e35';
327
+ let {stdout, stderr} = await execBin(`hex2diag ${ input }`);
197
328
  assert.strictEqual(stderr, '');
198
- assert.strictEqual(stdout, `{
199
- "a": 1,
200
- "b": [
201
- 2,
202
- 3
203
- ],
204
- "smile": "😀"
205
- }
329
+ assert.strictEqual(stdout, `78 64 # string(86)
330
+ f55ff8f12508b63ef2bfeca7557ae90df6311a5ec1631b # "õ_øñ%\\x08¶>ò¿ì§Uzé\\x0dö1\\x1a^Ác\\x1b"
331
+ 4a1fa843310bd9c3a710eaace5a1bdd72ad0bfe049771c # "J\\x1f¨C1\\x0bÙç\\x10ê¬å¡½×*пàIw\\x1c"
332
+ 11e756338bd93865e645f1adec9b9c99ef407fbd4fc685 # "\\x11çV3\\x8bÙ8eæEñ\\xadì\\x9b\\x9c\\x99ï@\\x7f½OÆ\\x85"
333
+ 9e7904c5ad7dc9bd10a5cc16973d5b28ec1a6dd43d9f82 # "\\x9ey\\x04Å\\xad}ɽ\\x10¥Ì\\x16\\x97=[(ì\\x1amÔ=\\x9f\\x82"
334
+ f9f18c3d03418e35 # "ùñ\\x8c=\\x03A\\x8e5"
206
335
  `);
207
- });
208
- it('bin2hex (stdin)', async () => {
209
- const {stdout, stderr} = await execBin('bin2hex', fromHex('a3616101616282020365736d696c6564f09f9880'));
336
+ ({stdout, stderr} = await execBin('diag2hex', stdout));
210
337
  assert.strictEqual(stderr, '');
211
- assert.strictEqual(stdout, 'a3616101616282020365736d696c6564f09f9880\n');
338
+ assert.strictEqual(stdout, `${ input }\n`);
212
339
  });
213
340
  });
package/esm/lib/3string.js CHANGED
@@ -8,29 +8,36 @@ import {
8
8
  } from './common.js';
9
9
  import * as uint from './0uint.js';
10
10
  import { encodeBytes } from './2bytes.js';
11
- import { toString } from './byte-utils.js';
12
- function toToken(data, pos, prefix, length) {
11
+ import {
12
+ toString,
13
+ slice
14
+ } from './byte-utils.js';
15
+ function toToken(data, pos, prefix, length, options) {
13
16
  const totLength = prefix + length;
14
17
  assertEnoughData(data, pos, totLength);
15
- return new Token(Type.string, toString(data, pos + prefix, pos + totLength), totLength);
18
+ const tok = new Token(Type.string, toString(data, pos + prefix, pos + totLength), totLength);
19
+ if (options.retainStringBytes === true) {
20
+ tok.byteValue = slice(data, pos + prefix, pos + totLength);
21
+ }
22
+ return tok;
16
23
  }
17
- export function decodeStringCompact(data, pos, minor, _options) {
18
- return toToken(data, pos, 1, minor);
24
+ export function decodeStringCompact(data, pos, minor, options) {
25
+ return toToken(data, pos, 1, minor, options);
19
26
  }
20
27
  export function decodeString8(data, pos, _minor, options) {
21
- return toToken(data, pos, 2, uint.readUint8(data, pos + 1, options));
28
+ return toToken(data, pos, 2, uint.readUint8(data, pos + 1, options), options);
22
29
  }
23
30
  export function decodeString16(data, pos, _minor, options) {
24
- return toToken(data, pos, 3, uint.readUint16(data, pos + 1, options));
31
+ return toToken(data, pos, 3, uint.readUint16(data, pos + 1, options), options);
25
32
  }
26
33
  export function decodeString32(data, pos, _minor, options) {
27
- return toToken(data, pos, 5, uint.readUint32(data, pos + 1, options));
34
+ return toToken(data, pos, 5, uint.readUint32(data, pos + 1, options), options);
28
35
  }
29
36
  export function decodeString64(data, pos, _minor, options) {
30
37
  const l = uint.readUint64(data, pos + 1, options);
31
38
  if (typeof l === 'bigint') {
32
39
  throw new Error(`${ decodeErrPrefix } 64-bit integer string lengths not supported`);
33
40
  }
34
- return toToken(data, pos, 9, l);
41
+ return toToken(data, pos, 9, l, options);
35
42
  }
36
43
  export const encodeString = encodeBytes;
package/esm/lib/bin.js CHANGED
@@ -3,7 +3,10 @@ import {
3
3
  decode,
4
4
  encode
5
5
  } from '../cborg.js';
6
- import { tokensToDiagnostic } from './diagnostic.js';
6
+ import {
7
+ tokensToDiagnostic,
8
+ fromDiag
9
+ } from './diagnostic.js';
7
10
  import {
8
11
  fromHex as _fromHex,
9
12
  toHex
@@ -11,15 +14,18 @@ import {
11
14
  function usage(code) {
12
15
  console.error('Usage: cborg <command> <args>');
13
16
  console.error('Valid commands:');
14
- console.error('\thex2diag [hex input]');
15
- console.error('\thex2bin [hex input]');
16
- console.error('\thex2json [--pretty] [hex input]');
17
- console.error('\tbin2hex [binary input]');
18
17
  console.error('\tbin2diag [binary input]');
18
+ console.error('\tbin2hex [binary input]');
19
19
  console.error('\tbin2json [--pretty] [binary input]');
20
- console.error('\tjson2hex \'[json input]\'');
21
- console.error('\tjson2diag \'[json input]\'');
20
+ console.error('\tdiag2bin [diagnostic input]');
21
+ console.error('\tdiag2hex [diagnostic input]');
22
+ console.error('\tdiag2json [--pretty] [diagnostic input]');
23
+ console.error('\thex2bin [hex input]');
24
+ console.error('\thex2diag [hex input]');
25
+ console.error('\thex2json [--pretty] [hex input]');
22
26
  console.error('\tjson2bin \'[json input]\'');
27
+ console.error('\tjson2diag \'[json input]\'');
28
+ console.error('\tjson2hex \'[json input]\'');
23
29
  console.error('Input may either be supplied as an argument or piped via stdin');
24
30
  process.exit(code || 0);
25
31
  }
@@ -51,22 +57,13 @@ async function run() {
51
57
  case 'help': {
52
58
  return usage(0);
53
59
  }
54
- case 'hex2json': {
55
- const {argv, pretty} = argvPretty();
56
- const bin = fromHex(argv.length < 4 ? (await fromStdin()).toString() : argv[3]);
57
- return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined));
58
- }
59
- case 'hex2diag': {
60
- const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]);
60
+ case 'bin2diag': {
61
+ const bin = process.argv.length < 4 ? await fromStdin() : new TextEncoder().encode(process.argv[3]);
61
62
  for (const line of tokensToDiagnostic(bin)) {
62
63
  console.log(line);
63
64
  }
64
65
  return;
65
66
  }
66
- case 'hex2bin': {
67
- const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]);
68
- return process.stdout.write(bin);
69
- }
70
67
  case 'bin2hex': {
71
68
  const bin = process.argv.length < 4 ? await fromStdin() : new TextEncoder().encode(process.argv[3]);
72
69
  return console.log(toHex(bin));
@@ -76,17 +73,39 @@ async function run() {
76
73
  const bin = argv.length < 4 ? await fromStdin() : new TextEncoder().encode(argv[3]);
77
74
  return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined));
78
75
  }
79
- case 'bin2diag': {
80
- const bin = process.argv.length < 4 ? await fromStdin() : new TextEncoder().encode(process.argv[3]);
76
+ case 'diag2bin': {
77
+ const bin = fromDiag(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]);
78
+ return process.stdout.write(bin);
79
+ }
80
+ case 'diag2hex': {
81
+ const bin = fromDiag(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]);
82
+ return console.log(toHex(bin));
83
+ }
84
+ case 'diag2json': {
85
+ const {argv, pretty} = argvPretty();
86
+ const bin = fromDiag(argv.length < 4 ? (await fromStdin()).toString() : argv[3]);
87
+ return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined));
88
+ }
89
+ case 'hex2bin': {
90
+ const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]);
91
+ return process.stdout.write(bin);
92
+ }
93
+ case 'hex2diag': {
94
+ const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]);
81
95
  for (const line of tokensToDiagnostic(bin)) {
82
96
  console.log(line);
83
97
  }
84
98
  return;
85
99
  }
86
- case 'json2hex': {
100
+ case 'hex2json': {
101
+ const {argv, pretty} = argvPretty();
102
+ const bin = fromHex(argv.length < 4 ? (await fromStdin()).toString() : argv[3]);
103
+ return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined));
104
+ }
105
+ case 'json2bin': {
87
106
  const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3];
88
107
  const obj = JSON.parse(inp);
89
- return console.log(toHex(encode(obj)));
108
+ return process.stdout.write(encode(obj));
90
109
  }
91
110
  case 'json2diag': {
92
111
  const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3];
@@ -96,10 +115,10 @@ async function run() {
96
115
  }
97
116
  return;
98
117
  }
99
- case 'json2bin': {
118
+ case 'json2hex': {
100
119
  const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3];
101
120
  const obj = JSON.parse(inp);
102
- return process.stdout.write(encode(obj));
121
+ return console.log(toHex(encode(obj)));
103
122
  }
104
123
  default: {
105
124
  if (process.argv.findIndex(a => a.endsWith('mocha')) === -1) {