@fedify/vocab-tools 2.5.0-dev.2619 → 2.5.0-dev.2687

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.
package/src/codec.test.ts CHANGED
@@ -99,14 +99,16 @@ async function withFixture(
99
99
  entity: false,
100
100
  description: "An embedded value.",
101
101
  defaultContext: [AS, CONTEXT] as unknown as TypeSchema["defaultContext"],
102
- properties: [{
103
- singularName: "label",
104
- functional: true,
105
- uri: `${NS}label`,
106
- compactName: "label",
107
- description: "A label.",
108
- range: [`${XSD}string`],
109
- }],
102
+ properties: [
103
+ {
104
+ singularName: "label",
105
+ functional: true,
106
+ uri: `${NS}label`,
107
+ compactName: "label",
108
+ description: "A label.",
109
+ range: [`${XSD}string`],
110
+ },
111
+ ],
110
112
  },
111
113
  };
112
114
  const source = (await Array.fromAsync(generateClasses(types))).join("");
@@ -134,34 +136,36 @@ const document = (properties: Record<string, unknown>) => ({
134
136
 
135
137
  test("redundant properties select the first non-empty entire set", async () => {
136
138
  await withFixture({}, async (Fixture, contextLoader) => {
137
- for (
138
- const [properties, expected] of [
139
- [{ [`${NS}first`]: [literal("a"), literal("b"), literal("a")] }, [
140
- "a",
141
- "b",
142
- "a",
143
- ]],
144
- [{ [`${NS}value`]: [], [`${NS}first`]: [literal("a")] }, ["a"]],
145
- [{ [`${NS}first`]: [], [`${NS}second`]: [literal("b")] }, ["b"]],
146
- [{ [`${NS}value`]: [literal("c")], [`${NS}first`]: [literal("a")] }, [
147
- "c",
148
- ]],
149
- [{ [`${NS}first`]: [literal("a")], [`${NS}second`]: [literal("b")] }, [
150
- "a",
151
- ]],
152
- [{}, []],
153
- ] as const
154
- ) {
139
+ for (const [properties, expected] of [
140
+ [
141
+ { [`${NS}first`]: [literal("a"), literal("b"), literal("a")] },
142
+ ["a", "b", "a"],
143
+ ],
144
+ [{ [`${NS}value`]: [], [`${NS}first`]: [literal("a")] }, ["a"]],
145
+ [{ [`${NS}first`]: [], [`${NS}second`]: [literal("b")] }, ["b"]],
146
+ [
147
+ { [`${NS}value`]: [literal("c")], [`${NS}first`]: [literal("a")] },
148
+ ["c"],
149
+ ],
150
+ [
151
+ { [`${NS}first`]: [literal("a")], [`${NS}second`]: [literal("b")] },
152
+ ["a"],
153
+ ],
154
+ [{}, []],
155
+ ] as const) {
155
156
  const parsed = await Fixture.fromJsonLd(document(properties), {
156
157
  contextLoader,
157
158
  });
158
159
  deepStrictEqual(parsed.values, expected);
159
160
  }
160
- const parsed = await Fixture.fromJsonLd({
161
- "@context": termsForRead(),
162
- type: "Fixture",
163
- alternate: ["a", "b", "a"],
164
- }, { contextLoader });
161
+ const parsed = await Fixture.fromJsonLd(
162
+ {
163
+ "@context": termsForRead(),
164
+ type: "Fixture",
165
+ alternate: ["a", "b", "a"],
166
+ },
167
+ { contextLoader },
168
+ );
165
169
  deepStrictEqual(parsed.values, ["a", "b", "a"]);
166
170
  });
167
171
  });
@@ -171,21 +175,24 @@ function termsForRead() {
171
175
  }
172
176
 
173
177
  test("redundant properties do not retry invalid canonical values", async () => {
174
- await withFixture({
175
- range: [
176
- `${XSD}string`,
177
- "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString",
178
- ],
179
- }, async (Fixture, contextLoader) => {
180
- const parsed = await Fixture.fromJsonLd(
181
- document({
182
- [`${NS}value`]: [literal(42)],
183
- [`${NS}first`]: [literal("fallback")],
184
- }),
185
- { contextLoader },
186
- );
187
- deepStrictEqual(parsed.values, []);
188
- });
178
+ await withFixture(
179
+ {
180
+ range: [
181
+ `${XSD}string`,
182
+ "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString",
183
+ ],
184
+ },
185
+ async (Fixture, contextLoader) => {
186
+ const parsed = await Fixture.fromJsonLd(
187
+ document({
188
+ [`${NS}value`]: [literal(42)],
189
+ [`${NS}first`]: [literal("fallback")],
190
+ }),
191
+ { contextLoader },
192
+ );
193
+ deepStrictEqual(parsed.values, []);
194
+ },
195
+ );
189
196
  await withFixture(
190
197
  { range: ["fedify:url"] },
191
198
  async (Fixture, contextLoader) => {
@@ -202,13 +209,15 @@ test("redundant properties do not retry invalid canonical values", async () => {
202
209
  await withFixture(
203
210
  { range: [`${XSD}anyURI`] },
204
211
  async (Fixture, contextLoader) => {
205
- await rejects(Fixture.fromJsonLd(
206
- document({
207
- [`${NS}value`]: [{ "@id": "http://[" }],
208
- [`${NS}first`]: [{ "@id": "https://example.com/fallback" }],
209
- }),
210
- { contextLoader },
211
- ));
212
+ await rejects(
213
+ Fixture.fromJsonLd(
214
+ document({
215
+ [`${NS}value`]: [{ "@id": "http://[" }],
216
+ [`${NS}first`]: [{ "@id": "https://example.com/fallback" }],
217
+ }),
218
+ { contextLoader },
219
+ ),
220
+ );
212
221
  },
213
222
  );
214
223
  });
@@ -225,10 +234,10 @@ for (const policy of [undefined, "all", "canonical"] as const) {
225
234
  contextLoader,
226
235
  });
227
236
  deepStrictEqual(await instance.toJsonLd({ contextLoader }), compact);
228
- const expanded = await instance.toJsonLd({
237
+ const expanded = (await instance.toJsonLd({
229
238
  format: "expand",
230
239
  contextLoader,
231
- }) as unknown as Record<string, unknown>[];
240
+ })) as unknown as Record<string, unknown>[];
232
241
  for (const alias of ["first", "second"]) {
233
242
  if (policy === "canonical" || values.length === 0) {
234
243
  ok(!(alias in compact));
@@ -264,83 +273,93 @@ for (const policy of [undefined, "all", "canonical"] as const) {
264
273
  for (const container of ["list", "graph"] as const) {
265
274
  for (const policy of ["all", "canonical"] as const) {
266
275
  test(`redundant ${container} containers with ${policy} writes`, async () => {
267
- await withFixture({
268
- container,
269
- redundantPropertiesWrite: policy,
270
- range: container === "graph" ? [`${NS}Value`] : [`${XSD}string`],
271
- }, async (Fixture, contextLoader) => {
272
- const items = container === "list"
273
- ? [literal("a"), literal("b"), literal("a")]
274
- : [
275
- { "@type": [`${NS}Value`], [`${NS}label`]: [literal("a")] },
276
- { "@type": [`${NS}Value`], [`${NS}label`]: [literal("b")] },
277
- ];
278
- const set = container === "list"
279
- ? [{ "@list": items }]
280
- : items.map((item) => ({ "@graph": [item] }));
281
- const parsed = await Fixture.fromJsonLd(
282
- document({
283
- [`${NS}first`]: set,
284
- [`${NS}second`]: [{ "@list": [literal("other")] }],
285
- }),
286
- { contextLoader },
287
- );
288
- deepStrictEqual(
289
- container === "list"
290
- ? parsed.values
291
- : parsed.values.map((v) => (v as { label: string }).label),
292
- container === "list" ? ["a", "b", "a"] : ["a", "b"],
293
- );
294
- const instance = new Fixture({ values: parsed.values });
295
- const compact = await instance.toJsonLd({
296
- format: "compact",
297
- contextLoader,
298
- });
299
- if (container === "list" || policy === "all") {
300
- deepStrictEqual(await instance.toJsonLd({ contextLoader }), compact);
301
- } else {
302
- // Parsed children retain expanded caches in the heuristic path.
303
- const defaultOutput = await instance.toJsonLd({ contextLoader });
304
- const decoded = await Fixture.fromJsonLd(defaultOutput, {
305
- contextLoader,
306
- });
276
+ await withFixture(
277
+ {
278
+ container,
279
+ redundantPropertiesWrite: policy,
280
+ range: container === "graph" ? [`${NS}Value`] : [`${XSD}string`],
281
+ },
282
+ async (Fixture, contextLoader) => {
283
+ const items =
284
+ container === "list"
285
+ ? [literal("a"), literal("b"), literal("a")]
286
+ : [
287
+ { "@type": [`${NS}Value`], [`${NS}label`]: [literal("a")] },
288
+ { "@type": [`${NS}Value`], [`${NS}label`]: [literal("b")] },
289
+ ];
290
+ const set =
291
+ container === "list"
292
+ ? [{ "@list": items }]
293
+ : items.map((item) => ({ "@graph": [item] }));
294
+ const parsed = await Fixture.fromJsonLd(
295
+ document({
296
+ [`${NS}first`]: set,
297
+ [`${NS}second`]: [{ "@list": [literal("other")] }],
298
+ }),
299
+ { contextLoader },
300
+ );
307
301
  deepStrictEqual(
308
- decoded.values.map((v) => (v as { label: string }).label),
309
- ["a", "b"],
302
+ container === "list"
303
+ ? parsed.values
304
+ : parsed.values.map((v) => (v as { label: string }).label),
305
+ container === "list" ? ["a", "b", "a"] : ["a", "b"],
310
306
  );
311
- }
312
- const expanded = await instance.toJsonLd({
313
- format: "expand",
314
- contextLoader,
315
- }) as unknown as Record<string, unknown>[];
316
- for (const alias of ["first", "second"]) {
317
- if (policy === "canonical") {
318
- ok(!(`${NS}${alias}` in expanded[0]));
319
- ok(!(alias in compact));
307
+ const instance = new Fixture({ values: parsed.values });
308
+ const compact = await instance.toJsonLd({
309
+ format: "compact",
310
+ contextLoader,
311
+ });
312
+ if (container === "list" || policy === "all") {
313
+ deepStrictEqual(
314
+ await instance.toJsonLd({ contextLoader }),
315
+ compact,
316
+ );
320
317
  } else {
318
+ // Parsed children retain expanded caches in the heuristic path.
319
+ const defaultOutput = await instance.toJsonLd({ contextLoader });
320
+ const decoded = await Fixture.fromJsonLd(defaultOutput, {
321
+ contextLoader,
322
+ });
321
323
  deepStrictEqual(
322
- expanded[0][`${NS}${alias}`],
323
- expanded[0][`${NS}value`],
324
+ decoded.values.map((v) => (v as { label: string }).label),
325
+ ["a", "b"],
324
326
  );
325
- deepStrictEqual(compact[alias], compact.value);
326
327
  }
327
- }
328
- const roundtrip = await Fixture.fromJsonLd(compact, { contextLoader });
329
- deepStrictEqual(
330
- container === "list"
331
- ? roundtrip.values
332
- : roundtrip.values.map((v) => (v as { label: string }).label),
333
- container === "list" ? ["a", "b", "a"] : ["a", "b"],
334
- );
335
- const empty = await Fixture.fromJsonLd(
336
- document({
337
- [`${NS}value`]: [{ [`@${container}`]: [] }],
338
- [`${NS}first`]: set,
339
- }),
340
- { contextLoader },
341
- );
342
- deepStrictEqual(empty.values, []);
343
- });
328
+ const expanded = (await instance.toJsonLd({
329
+ format: "expand",
330
+ contextLoader,
331
+ })) as unknown as Record<string, unknown>[];
332
+ for (const alias of ["first", "second"]) {
333
+ if (policy === "canonical") {
334
+ ok(!(`${NS}${alias}` in expanded[0]));
335
+ ok(!(alias in compact));
336
+ } else {
337
+ deepStrictEqual(
338
+ expanded[0][`${NS}${alias}`],
339
+ expanded[0][`${NS}value`],
340
+ );
341
+ deepStrictEqual(compact[alias], compact.value);
342
+ }
343
+ }
344
+ const roundtrip = await Fixture.fromJsonLd(compact, {
345
+ contextLoader,
346
+ });
347
+ deepStrictEqual(
348
+ container === "list"
349
+ ? roundtrip.values
350
+ : roundtrip.values.map((v) => (v as { label: string }).label),
351
+ container === "list" ? ["a", "b", "a"] : ["a", "b"],
352
+ );
353
+ const empty = await Fixture.fromJsonLd(
354
+ document({
355
+ [`${NS}value`]: [{ [`@${container}`]: [] }],
356
+ [`${NS}first`]: set,
357
+ }),
358
+ { contextLoader },
359
+ );
360
+ deepStrictEqual(empty.values, []);
361
+ },
362
+ );
344
363
  });
345
364
  }
346
365
  }
@@ -348,132 +367,146 @@ for (const container of ["list", "graph"] as const) {
348
367
  for (const functional of [false, true]) {
349
368
  test(`URI-only aliases and portable read keys (functional=${functional})`, async () => {
350
369
  for (const policy of ["all", "canonical"] as const) {
351
- await withFixture({
352
- ...(functional ? { functional: true } : {}),
353
- range: [`${XSD}anyURI`],
354
- redundantPropertiesWrite: policy,
355
- redundantProperties: [{ uri: `${NS}first` }],
356
- }, async (Fixture, contextLoader, source) => {
357
- ok(!source.includes("result[undefined]"));
358
- match(source, /PORTABLE_IRI_KEYS[^\n]+https:\/\/example.com\/first/);
359
- const url = new URL("https://example.com/object");
360
- const instance = new Fixture(
361
- functional ? { value: url } : { values: [url] },
362
- );
363
- const compact = await instance.toJsonLd({
364
- format: "compact",
365
- contextLoader,
366
- });
367
- deepStrictEqual(await instance.toJsonLd({ contextLoader }), compact);
368
- const expanded = await instance.toJsonLd({
369
- format: "expand",
370
- contextLoader,
371
- }) as unknown as Record<string, unknown>[];
372
- if (policy === "all") {
373
- deepStrictEqual(expanded[0][`${NS}first`], [{ "@id": url.href }]);
374
- } else ok(!(`${NS}first` in expanded[0]));
375
- const custom = await instance.toJsonLd({
376
- format: "compact",
377
- contextLoader,
378
- context: {
379
- type: "@type",
380
- Fixture: `${NS}Fixture`,
381
- value: { "@id": `${NS}value`, "@type": "@id" },
382
- },
383
- });
384
- if (policy === "all") {
385
- deepStrictEqual(custom[`${NS}first`], { "@id": url.href });
386
- } else {
387
- ok(!(`${NS}first` in custom));
388
- }
389
- const parsed = await Fixture.fromJsonLd(
390
- document({
391
- [`${NS}first`]: [{ "@id": "ap://did:key:z6Mkabc/objects/1" }],
392
- }),
393
- { contextLoader },
394
- );
395
- const value = functional ? parsed.value : parsed.values[0];
396
- ok(value instanceof URL);
397
- const cached = await parsed.toJsonLd({ contextLoader });
398
- deepStrictEqual(cached[`${NS}first`], [{
399
- "@id": "ap+ef61://did:key:z6Mkabc/objects/1",
400
- }]);
401
- const compactInput = await Fixture.fromJsonLd({
402
- "@context": [AS, CONTEXT],
403
- type: "Fixture",
404
- first: "ap://did:key:z6Mkabc/objects/1",
405
- }, { contextLoader });
406
- const compactCache = await compactInput.toJsonLd({ contextLoader });
407
- deepStrictEqual(
408
- compactCache.first,
409
- "ap+ef61://did:key:z6Mkabc/objects/1",
410
- );
411
- });
370
+ await withFixture(
371
+ {
372
+ ...(functional ? { functional: true } : {}),
373
+ range: [`${XSD}anyURI`],
374
+ redundantPropertiesWrite: policy,
375
+ redundantProperties: [{ uri: `${NS}first` }],
376
+ },
377
+ async (Fixture, contextLoader, source) => {
378
+ ok(!source.includes("result[undefined]"));
379
+ match(source, /PORTABLE_IRI_KEYS[^\n]+https:\/\/example.com\/first/);
380
+ const url = new URL("https://example.com/object");
381
+ const instance = new Fixture(
382
+ functional ? { value: url } : { values: [url] },
383
+ );
384
+ const compact = await instance.toJsonLd({
385
+ format: "compact",
386
+ contextLoader,
387
+ });
388
+ deepStrictEqual(await instance.toJsonLd({ contextLoader }), compact);
389
+ const expanded = (await instance.toJsonLd({
390
+ format: "expand",
391
+ contextLoader,
392
+ })) as unknown as Record<string, unknown>[];
393
+ if (policy === "all") {
394
+ deepStrictEqual(expanded[0][`${NS}first`], [{ "@id": url.href }]);
395
+ } else ok(!(`${NS}first` in expanded[0]));
396
+ const custom = await instance.toJsonLd({
397
+ format: "compact",
398
+ contextLoader,
399
+ context: {
400
+ type: "@type",
401
+ Fixture: `${NS}Fixture`,
402
+ value: { "@id": `${NS}value`, "@type": "@id" },
403
+ },
404
+ });
405
+ if (policy === "all") {
406
+ deepStrictEqual(custom[`${NS}first`], { "@id": url.href });
407
+ } else {
408
+ ok(!(`${NS}first` in custom));
409
+ }
410
+ const parsed = await Fixture.fromJsonLd(
411
+ document({
412
+ [`${NS}first`]: [{ "@id": "ap://did:key:z6Mkabc/objects/1" }],
413
+ }),
414
+ { contextLoader },
415
+ );
416
+ const value = functional ? parsed.value : parsed.values[0];
417
+ ok(value instanceof URL);
418
+ const cached = await parsed.toJsonLd({ contextLoader });
419
+ deepStrictEqual(cached[`${NS}first`], [
420
+ {
421
+ "@id": "ap+ef61://did:key:z6Mkabc/objects/1",
422
+ },
423
+ ]);
424
+ const compactInput = await Fixture.fromJsonLd(
425
+ {
426
+ "@context": [AS, CONTEXT],
427
+ type: "Fixture",
428
+ first: "ap://did:key:z6Mkabc/objects/1",
429
+ },
430
+ { contextLoader },
431
+ );
432
+ const compactCache = await compactInput.toJsonLd({ contextLoader });
433
+ deepStrictEqual(
434
+ compactCache.first,
435
+ "ap+ef61://did:key:z6Mkabc/objects/1",
436
+ );
437
+ },
438
+ );
412
439
  }
413
440
  });
414
441
  }
415
442
 
416
443
  test("absolute IRIs are read from nodes and plain literals without a base", async () => {
417
- await withFixture({
418
- range: ["fedify:absoluteIri"],
419
- redundantPropertiesWrite: "canonical",
420
- redundantProperties: [{ uri: `${NS}first` }],
421
- }, async (Fixture, contextLoader, source) => {
422
- match(source, /PORTABLE_IRI_KEYS[^\n]+https:\/\/example.com\/value/);
423
- match(source, /PORTABLE_IRI_KEYS[^\n]+https:\/\/example.com\/first/);
424
- const values = [
425
- { "@id": "https://example.com/node" },
426
- literal("urn:example:literal"),
427
- { "@value": "https://example.com/any-uri", "@type": `${XSD}anyURI` },
428
- { "@value": "https://example.com/string", "@type": `${XSD}string` },
429
- // A context's default language tags uncoerced strings:
430
- { "@value": "https://example.com/tagged", "@language": "und" },
431
- // Relative IRIs are never resolved against the object's ID:
432
- { "@id": "CC-BY-4.0" },
433
- { "@id": "_:b0" },
434
- literal("Creative Commons Attribution 4.0 International"),
435
- { "@value": "https://example.com/date", "@type": `${XSD}date` },
436
- ];
437
- const expected = [
438
- new URL("https://example.com/node"),
439
- new URL("urn:example:literal"),
440
- new URL("https://example.com/any-uri"),
441
- new URL("https://example.com/string"),
442
- new URL("https://example.com/tagged"),
443
- ];
444
- for (const key of ["value", "first"]) {
445
- const parsed = await Fixture.fromJsonLd(
446
- {
447
- "@id": "https://example.com/objects/1",
448
- ...document({ [`${NS}${key}`]: values }),
449
- },
450
- { contextLoader, baseUrl: new URL("https://example.com/base/") },
444
+ await withFixture(
445
+ {
446
+ range: ["fedify:absoluteIri"],
447
+ redundantPropertiesWrite: "canonical",
448
+ redundantProperties: [{ uri: `${NS}first` }],
449
+ },
450
+ async (Fixture, contextLoader, source) => {
451
+ match(source, /PORTABLE_IRI_KEYS[^\n]+https:\/\/example.com\/value/);
452
+ match(source, /PORTABLE_IRI_KEYS[^\n]+https:\/\/example.com\/first/);
453
+ const values = [
454
+ { "@id": "https://example.com/node" },
455
+ literal("urn:example:literal"),
456
+ { "@value": "https://example.com/any-uri", "@type": `${XSD}anyURI` },
457
+ { "@value": "https://example.com/string", "@type": `${XSD}string` },
458
+ // A context's default language tags uncoerced strings:
459
+ { "@value": "https://example.com/tagged", "@language": "und" },
460
+ // Relative IRIs are never resolved against the object's ID:
461
+ { "@id": "CC-BY-4.0" },
462
+ { "@id": "_:b0" },
463
+ literal("Creative Commons Attribution 4.0 International"),
464
+ { "@value": "https://example.com/date", "@type": `${XSD}date` },
465
+ ];
466
+ const expected = [
467
+ new URL("https://example.com/node"),
468
+ new URL("urn:example:literal"),
469
+ new URL("https://example.com/any-uri"),
470
+ new URL("https://example.com/string"),
471
+ new URL("https://example.com/tagged"),
472
+ ];
473
+ for (const key of ["value", "first"]) {
474
+ const parsed = await Fixture.fromJsonLd(
475
+ {
476
+ "@id": "https://example.com/objects/1",
477
+ ...document({ [`${NS}${key}`]: values }),
478
+ },
479
+ { contextLoader, baseUrl: new URL("https://example.com/base/") },
480
+ );
481
+ deepStrictEqual(parsed.values, expected);
482
+ }
483
+ // An invalid canonical set is not replaced by a synonym:
484
+ const invalid = await Fixture.fromJsonLd(
485
+ document({
486
+ [`${NS}value`]: [{ "@id": "CC-BY-4.0" }],
487
+ [`${NS}first`]: [{ "@id": "https://example.com/fallback" }],
488
+ }),
489
+ { contextLoader },
451
490
  );
452
- deepStrictEqual(parsed.values, expected);
453
- }
454
- // An invalid canonical set is not replaced by a synonym:
455
- const invalid = await Fixture.fromJsonLd(
456
- document({
457
- [`${NS}value`]: [{ "@id": "CC-BY-4.0" }],
458
- [`${NS}first`]: [{ "@id": "https://example.com/fallback" }],
459
- }),
460
- { contextLoader },
461
- );
462
- deepStrictEqual(invalid.values, []);
463
- const instance = new Fixture({ values: expected });
464
- const expanded = await instance.toJsonLd({
465
- format: "expand",
466
- contextLoader,
467
- }) as unknown as Record<string, unknown>[];
468
- deepStrictEqual(
469
- expanded[0][`${NS}value`],
470
- expected.map((url) => ({ "@id": url.href })),
471
- );
472
- ok(!(`${NS}first` in expanded[0]));
473
- const compact = await instance.toJsonLd({
474
- format: "compact",
475
- contextLoader,
476
- });
477
- deepStrictEqual(compact.value, expected.map((url) => url.href));
478
- });
491
+ deepStrictEqual(invalid.values, []);
492
+ const instance = new Fixture({ values: expected });
493
+ const expanded = (await instance.toJsonLd({
494
+ format: "expand",
495
+ contextLoader,
496
+ })) as unknown as Record<string, unknown>[];
497
+ deepStrictEqual(
498
+ expanded[0][`${NS}value`],
499
+ expected.map((url) => ({ "@id": url.href })),
500
+ );
501
+ ok(!(`${NS}first` in expanded[0]));
502
+ const compact = await instance.toJsonLd({
503
+ format: "compact",
504
+ contextLoader,
505
+ });
506
+ deepStrictEqual(
507
+ compact.value,
508
+ expected.map((url) => url.href),
509
+ );
510
+ },
511
+ );
479
512
  });