@twin.org/data-json-ld 0.0.1-next.8 → 0.0.1

package/dist/esm/index.mjs

@@ -1,115 +1,142 @@
 import { DataTypeHandlerFactory, DataTypeHelper } from '@twin.org/data-core';
-import { Is, GeneralError, ObjectHelper } from '@twin.org/core';
-import { FetchHelper, HttpMethod, MimeTypes } from '@twin.org/web';
+import { SharedStore, Is, ObjectHelper, GeneralError, BaseError, ArrayHelper } from '@twin.org/core';
+import { FetchHelper, HttpMethod, HeaderTypes, MimeTypes } from '@twin.org/web';
 import jsonLd from 'jsonld';
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * The types of JSON-LD data.
+ * The contexts of JSON-LD data.
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const JsonLdTypes = {
+const JsonLdContexts = {
     /**
      * Context Root.
      */
-    ContextRoot: "https://schema.twindev.org/json-ld/",
+    ContextRoot: "https://schema.twindev.org/json-ld/"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * The types of JSON-LD data.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const JsonLdTypes = {
     /**
      * Represents JSON-LD Document.
      */
-    Document: "https://schema.twindev.org/json-ld/JsonLdDocument",
+    Document: "JsonLdDocument",
+    /**
+     * Represents JSON-LD Object.
+     */
+    Object: "JsonLdObject",
     /**
      * Represents JSON-LD Node Object.
      */
-    NodeObject: "https://schema.twindev.org/json-ld/JsonLdNodeObject",
+    NodeObject: "JsonLdNodeObject",
     /**
      * Represents JSON-LD Node Primitive.
      */
-    NodePrimitive: "https://schema.twindev.org/json-ld/JsonLdNodePrimitive",
+    NodePrimitive: "JsonLdNodePrimitive",
     /**
      * Represents JSON-LD Graph Object.
      */
-    GraphObject: "https://schema.twindev.org/json-ld/JsonLdGraphObject",
+    GraphObject: "JsonLdGraphObject",
     /**
      * Represents JSON-LD Value Object.
      */
-    ValueObject: "https://schema.twindev.org/json-ld/JsonLdValueObject",
+    ValueObject: "JsonLdValueObject",
     /**
      * Represents JSON-LD List Object.
      */
-    ListObject: "https://schema.twindev.org/json-ld/JsonLdListObject",
+    ListObject: "JsonLdListObject",
     /**
      * Represents JSON-LD Set Object.
      */
-    SetObject: "https://schema.twindev.org/json-ld/JsonLdSetObject",
+    SetObject: "JsonLdSetObject",
     /**
      * Represents JSON-LD Language Map.
      */
-    LanguageMap: "https://schema.twindev.org/json-ld/JsonLdLanguageMap",
+    LanguageMap: "JsonLdLanguageMap",
     /**
      * Represents JSON-LD Index Map.
      */
-    IndexMap: "https://schema.twindev.org/json-ld/JsonLdIndexMap",
+    IndexMap: "JsonLdIndexMap",
     /**
      * Represents JSON-LD Index Map Item.
      */
-    IndexMapItem: "https://schema.twindev.org/json-ld/JsonLdIndexMapItem",
+    IndexMapItem: "JsonLdIndexMapItem",
     /**
      * Represents JSON-LD Id Map.
      */
-    IdMap: "https://schema.twindev.org/json-ld/JsonLdIdMap",
+    IdMap: "JsonLdIdMap",
     /**
      * Represents JSON-LD Type Map.
      */
-    TypeMap: "https://schema.twindev.org/json-ld/JsonLdTypeMap",
+    TypeMap: "JsonLdTypeMap",
     /**
      * Represents JSON-LD Included block.
      */
-    IncludedBlock: "https://schema.twindev.org/json-ld/JsonLdIncludedBlock",
+    IncludedBlock: "JsonLdIncludedBlock",
     /**
      * Represents JSON-LD Context Definition.
      */
-    ContextDefinition: "https://schema.twindev.org/json-ld/JsonLdContextDefinition",
+    ContextDefinition: "JsonLdContextDefinition",
+    /**
+     * Represents JSON-LD Context Definition Element.
+     */
+    ContextDefinitionElement: "JsonLdContextDefinitionElement",
+    /**
+     * Represents JSON-LD Context Definition Root.
+     */
+    ContextDefinitionRoot: "JsonLdContextDefinitionRoot",
     /**
      * Represents JSON-LD Expanded Term Definition.
      */
-    ExpandedTermDefinition: "https://schema.twindev.org/json-ld/JsonLdExpandedTermDefinition",
+    ExpandedTermDefinition: "JsonLdExpandedTermDefinition",
     /**
      * Represents JSON-LD Keyword.
      */
-    Keyword: "https://schema.twindev.org/json-ld/JsonLdKeyword",
+    Keyword: "JsonLdKeyword",
     /**
      * Represents JSON-LD List or Set Item.
      */
-    ListOrSetItem: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem",
+    ListOrSetItem: "JsonLdListOrSetItem",
     /**
      * Represents JSON-LD Container Type.
      */
-    ContainerType: "https://schema.twindev.org/json-ld/JsonLdContainerType",
+    ContainerType: "JsonLdContainerType",
     /**
      * Represents JSON-LD Container Type Array.
      */
-    ContainerTypeArray: "https://schema.twindev.org/json-ld/JsonLdContainerTypeArray",
+    ContainerTypeArray: "JsonLdContainerTypeArray",
     /**
      * Represents JSON-LD JSON Primitive.
      */
-    JsonPrimitive: "https://schema.twindev.org/json-ld/JsonLdJsonPrimitive",
+    JsonPrimitive: "JsonLdJsonPrimitive",
     /**
      * Represents JSON-LD JSON Array.
      */
-    JsonArray: "https://schema.twindev.org/json-ld/JsonLdJsonArray",
+    JsonArray: "JsonLdJsonArray",
     /**
      * Represents JSON-LD JSON Object.
      */
-    JsonObject: "https://schema.twindev.org/json-ld/JsonLdJsonObject",
+    JsonObject: "JsonLdJsonObject",
     /**
      * Represents JSON-LD JSON Value.
      */
-    JsonValue: "https://schema.twindev.org/json-ld/JsonLdJsonValue"
+    JsonValue: "JsonLdJsonValue"
 };
 
+var $schema$o = "https://json-schema.org/draft/2020-12/schema";
+var $id$o = "https://schema.twindev.org/json-ld/JsonLdContainerType";
+var description$o = "JSON-LD container types.";
 var type$d = "string";
 var JsonLdContainerTypeSchema = {
+	$schema: $schema$o,
+	$id: $id$o,
+	description: description$o,
 	type: type$d,
 	"enum": [
 	"@language",
@@ -120,11 +147,16 @@ var JsonLdContainerTypeSchema = {
 ]
 };
 
-var anyOf$8 = [
+var $schema$n = "https://json-schema.org/draft/2020-12/schema";
+var $id$n = "https://schema.twindev.org/json-ld/JsonLdContainerTypeArray";
+var description$n = "JSON-LD container type array.";
+var anyOf$a = [
 	{
 		type: "array",
 		minItems: 2,
-		items: [
+		items: false,
+		maxItems: 2,
+		prefixItems: [
 			{
 				type: "string",
 				"const": "@graph"
@@ -133,13 +165,14 @@ var anyOf$8 = [
 				type: "string",
 				"const": "@id"
 			}
-		],
-		maxItems: 2
+		]
 	},
 	{
 		type: "array",
 		minItems: 2,
-		items: [
+		items: false,
+		maxItems: 2,
+		prefixItems: [
 			{
 				type: "string",
 				"const": "@id"
@@ -148,13 +181,14 @@ var anyOf$8 = [
 				type: "string",
 				"const": "@graph"
 			}
-		],
-		maxItems: 2
+		]
 	},
 	{
 		type: "array",
 		minItems: 3,
-		items: [
+		items: false,
+		maxItems: 3,
+		prefixItems: [
 			{
 				type: "string",
 				"const": "@set"
@@ -167,13 +201,14 @@ var anyOf$8 = [
 				type: "string",
 				"const": "@id"
 			}
-		],
-		maxItems: 3
+		]
 	},
 	{
 		type: "array",
 		minItems: 3,
-		items: [
+		items: false,
+		maxItems: 3,
+		prefixItems: [
 			{
 				type: "string",
 				"const": "@set"
@@ -186,13 +221,14 @@ var anyOf$8 = [
 				type: "string",
 				"const": "@graph"
 			}
-		],
-		maxItems: 3
+		]
 	},
 	{
 		type: "array",
 		minItems: 3,
-		items: [
+		items: false,
+		maxItems: 3,
+		prefixItems: [
 			{
 				type: "string",
 				"const": "@graph"
@@ -205,13 +241,14 @@ var anyOf$8 = [
 				type: "string",
 				"const": "@id"
 			}
-		],
-		maxItems: 3
+		]
 	},
 	{
 		type: "array",
 		minItems: 3,
-		items: [
+		items: false,
+		maxItems: 3,
+		prefixItems: [
 			{
 				type: "string",
 				"const": "@id"
@@ -224,13 +261,14 @@ var anyOf$8 = [
 				type: "string",
 				"const": "@graph"
 			}
-		],
-		maxItems: 3
+		]
 	},
 	{
 		type: "array",
 		minItems: 3,
-		items: [
+		items: false,
+		maxItems: 3,
+		prefixItems: [
 			{
 				type: "string",
 				"const": "@graph"
@@ -243,13 +281,14 @@ var anyOf$8 = [
 				type: "string",
 				"const": "@set"
 			}
-		],
-		maxItems: 3
+		]
 	},
 	{
 		type: "array",
 		minItems: 3,
-		items: [
+		items: false,
+		maxItems: 3,
+		prefixItems: [
 			{
 				type: "string",
 				"const": "@id"
@@ -262,13 +301,14 @@ var anyOf$8 = [
 				type: "string",
 				"const": "@set"
 			}
-		],
-		maxItems: 3
+		]
 	},
 	{
 		type: "array",
 		minItems: 2,
-		items: [
+		items: false,
+		maxItems: 2,
+		prefixItems: [
 			{
 				type: "string",
 				"const": "@set"
@@ -276,13 +316,14 @@ var anyOf$8 = [
 			{
 				$ref: "https://schema.twindev.org/json-ld/JsonLdContainerType"
 			}
-		],
-		maxItems: 2
+		]
 	},
 	{
 		type: "array",
 		minItems: 2,
-		items: [
+		items: false,
+		maxItems: 2,
+		prefixItems: [
 			{
 				$ref: "https://schema.twindev.org/json-ld/JsonLdContainerType"
 			},
@@ -290,33 +331,49 @@ var anyOf$8 = [
 				type: "string",
 				"const": "@set"
 			}
-		],
-		maxItems: 2
+		]
 	}
 ];
 var JsonLdContainerTypeArraySchema = {
-	anyOf: anyOf$8
+	$schema: $schema$n,
+	$id: $id$n,
+	description: description$n,
+	anyOf: anyOf$a
 };
 
+var $schema$m = "https://json-schema.org/draft/2020-12/schema";
+var $id$m = "https://schema.twindev.org/json-ld/JsonLdContextDefinition";
+var description$m = "A context definition defines a local context in a node object.";
 var type$c = "object";
 var properties$5 = {
 	"@base": {
-		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+		type: [
+			"string",
+			"null"
+		]
 	},
 	"@direction": {
-		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+		type: [
+			"string",
+			"null"
+		],
+		"enum": [
+			"ltr",
+			"rtl",
+			null
+		]
 	},
 	"@import": {
-		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+		type: "string"
 	},
 	"@language": {
-		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+		type: "string"
 	},
 	"@propagate": {
-		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+		type: "boolean"
 	},
 	"@protected": {
-		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+		type: "boolean"
 	},
 	"@type": {
 		type: "object",
@@ -326,7 +383,7 @@ var properties$5 = {
 				"const": "@set"
 			},
 			"@protected": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "boolean"
 			}
 		},
 		required: [
@@ -335,10 +392,14 @@ var properties$5 = {
 		additionalProperties: false
 	},
 	"@version": {
-		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+		type: "string",
+		"const": "1.1"
 	},
 	"@vocab": {
-		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+		type: [
+			"string",
+			"null"
+		]
 	}
 };
 var additionalProperties$a = {
@@ -354,23 +415,75 @@ var additionalProperties$a = {
 		}
 	]
 };
-var description$g = "A context definition defines a local context in a node object.";
 var JsonLdContextDefinitionSchema = {
+	$schema: $schema$m,
+	$id: $id$m,
+	description: description$m,
 	type: type$c,
 	properties: properties$5,
-	additionalProperties: additionalProperties$a,
-	description: description$g
+	additionalProperties: additionalProperties$a
+};
+
+var $schema$l = "https://json-schema.org/draft/2020-12/schema";
+var $id$l = "https://schema.twindev.org/json-ld/JsonLdContextDefinitionElement";
+var description$l = "A context definition element is used to define the types of a context definition.";
+var anyOf$9 = [
+	{
+		type: "null"
+	},
+	{
+		type: "string"
+	},
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
+	}
+];
+var JsonLdContextDefinitionElementSchema = {
+	$schema: $schema$l,
+	$id: $id$l,
+	description: description$l,
+	anyOf: anyOf$9
+};
+
+var $schema$k = "https://json-schema.org/draft/2020-12/schema";
+var $id$k = "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot";
+var description$k = "A context definition root is used to define the root of a context definition.";
+var anyOf$8 = [
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionElement"
+	},
+	{
+		type: "array",
+		items: false,
+		prefixItems: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionElement"
+			}
+		]
+	}
+];
+var JsonLdContextDefinitionRootSchema = {
+	$schema: $schema$k,
+	$id: $id$k,
+	description: description$k,
+	anyOf: anyOf$8
 };
 
+var $schema$j = "https://json-schema.org/draft/2020-12/schema";
+var $id$j = "https://schema.twindev.org/json-ld/JsonLdDocument";
+var description$j = "A JSON-LD document MUST be valid JSON text as described in [RFC8259], or some format that can be represented in the JSON-LD internal representation that is equivalent to valid JSON text.";
 var anyOf$7 = [
 	{
 		$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
 	},
 	{
 		type: "array",
-		items: {
-			$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
-		}
+		items: false,
+		prefixItems: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+			}
+		]
 	},
 	{
 		type: "object",
@@ -388,16 +501,19 @@ var anyOf$7 = [
 					},
 					{
 						type: "array",
-						items: {
-							anyOf: [
-								{
-									$ref: "https://schema.twindev.org/json-ld/JsonLdValueObject"
-								},
-								{
-									$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
-								}
-							]
-						}
+						items: false,
+						prefixItems: [
+							{
+								anyOf: [
+									{
+										$ref: "https://schema.twindev.org/json-ld/JsonLdValueObject"
+									},
+									{
+										$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+									}
+								]
+							}
+						]
 					}
 				]
 			}
@@ -405,12 +521,16 @@ var anyOf$7 = [
 		additionalProperties: false
 	}
 ];
-var description$f = "A JSON-LD document MUST be valid JSON text as described in [RFC8259], or some format that can be represented in the JSON-LD internal representation that is equivalent to valid JSON text.";
 var JsonLdDocumentSchema = {
-	anyOf: anyOf$7,
-	description: description$f
+	$schema: $schema$j,
+	$id: $id$j,
+	description: description$j,
+	anyOf: anyOf$7
 };
 
+var $schema$i = "https://json-schema.org/draft/2020-12/schema";
+var $id$i = "https://schema.twindev.org/json-ld/JsonLdExpandedTermDefinition";
+var description$i = "An expanded term definition is used to describe the mapping between a term and its expanded identifier, as well as other properties of the value associated with the term when it is used as key in a node object.";
 var anyOf$6 = [
 	{
 		type: "object",
@@ -419,7 +539,16 @@ var anyOf$6 = [
 			"@id": {
 				anyOf: [
 					{
-						$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+						type: "string"
+					},
+					{
+						type: "array",
+						items: false,
+						prefixItems: [
+							{
+								type: "string"
+							}
+						]
 					},
 					{
 						type: "null"
@@ -430,28 +559,67 @@ var anyOf$6 = [
 				type: "string"
 			},
 			"@container": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				anyOf: [
+					{
+						type: "string",
+						"const": "@list"
+					},
+					{
+						type: "string",
+						"const": "@set"
+					},
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdContainerType"
+					},
+					{
+						type: "array",
+						items: false,
+						prefixItems: [
+							{
+								anyOf: [
+									{
+										type: "string",
+										"const": "@list"
+									},
+									{
+										type: "string",
+										"const": "@set"
+									},
+									{
+										$ref: "https://schema.twindev.org/json-ld/JsonLdContainerType"
+									}
+								]
+							}
+						]
+					},
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdContainerTypeArray"
+					},
+					{
+						type: "null"
+					}
+				]
 			},
 			"@type": {
 				type: "string"
 			},
 			"@language": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "string"
 			},
 			"@index": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "string"
 			},
 			"@context": {
 				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
 			},
 			"@prefix": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "boolean"
 			},
 			"@propagate": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "boolean"
 			},
 			"@protected": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "boolean"
 			}
 		}
 	},
@@ -460,7 +628,7 @@ var anyOf$6 = [
 		additionalProperties: false,
 		properties: {
 			"@reverse": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "string"
 			},
 			"@container": {
 				type: [
@@ -477,22 +645,22 @@ var anyOf$6 = [
 				type: "string"
 			},
 			"@language": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "string"
 			},
 			"@index": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "string"
 			},
 			"@context": {
 				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
 			},
 			"@prefix": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "boolean"
 			},
 			"@propagate": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "boolean"
 			},
 			"@protected": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "boolean"
 			}
 		},
 		required: [
@@ -500,12 +668,16 @@ var anyOf$6 = [
 		]
 	}
 ];
-var description$e = "An expanded term definition is used to describe the mapping between a term and its expanded identifier, as well as other properties of the value associated with the term when it is used as key in a node object.";
 var JsonLdExpandedTermDefinitionSchema = {
-	anyOf: anyOf$6,
-	description: description$e
+	$schema: $schema$i,
+	$id: $id$i,
+	description: description$i,
+	anyOf: anyOf$6
 };
 
+var $schema$h = "https://json-schema.org/draft/2020-12/schema";
+var $id$h = "https://schema.twindev.org/json-ld/JsonLdGraphObject";
+var description$h = "A graph object represents a named graph, which MAY include an explicit graph name.";
 var type$b = "object";
 var properties$4 = {
 	"@graph": {
@@ -515,9 +687,12 @@ var properties$4 = {
 			},
 			{
 				type: "array",
-				items: {
-					$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
-				}
+				items: false,
+				prefixItems: [
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+					}
+				]
 			}
 		]
 	},
@@ -531,9 +706,12 @@ var properties$4 = {
 			},
 			{
 				type: "array",
-				items: {
-					type: "string"
-				}
+				items: false,
+				prefixItems: [
+					{
+						type: "string"
+					}
+				]
 			}
 		]
 	},
@@ -541,47 +719,62 @@ var properties$4 = {
 		$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
 	}
 };
-var required$3 = [
+var required$2 = [
 	"@graph"
 ];
 var additionalProperties$9 = false;
-var description$d = "A graph object represents a named graph, which MAY include an explicit graph name.";
 var JsonLdGraphObjectSchema = {
+	$schema: $schema$h,
+	$id: $id$h,
+	description: description$h,
 	type: type$b,
 	properties: properties$4,
-	required: required$3,
-	additionalProperties: additionalProperties$9,
-	description: description$d
+	required: required$2,
+	additionalProperties: additionalProperties$9
 };
 
+var $schema$g = "https://json-schema.org/draft/2020-12/schema";
+var $id$g = "https://schema.twindev.org/json-ld/JsonLdIdMap";
+var description$g = "An id map is used to associate an IRI with a value that allows easy programmatic access.";
 var type$a = "object";
 var additionalProperties$8 = {
 	$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
 };
-var description$c = "An id map is used to associate an IRI with a value that allows easy programmatic access.";
 var JsonLdIdMapSchema = {
+	$schema: $schema$g,
+	$id: $id$g,
+	description: description$g,
 	type: type$a,
-	additionalProperties: additionalProperties$8,
-	description: description$c
+	additionalProperties: additionalProperties$8
 };
 
+var $schema$f = "https://json-schema.org/draft/2020-12/schema";
+var $id$f = "https://schema.twindev.org/json-ld/JsonLdIncludedBlock";
+var description$f = "An included block is used to provide a set of node objects.";
 var anyOf$5 = [
 	{
 		$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
 	},
 	{
 		type: "array",
-		items: {
-			$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
-		}
+		items: false,
+		prefixItems: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+			}
+		]
 	}
 ];
-var description$b = "An included block is used to provide a set of node objects.";
 var JsonLdIncludedBlockSchema = {
-	anyOf: anyOf$5,
-	description: description$b
+	$schema: $schema$f,
+	$id: $id$f,
+	description: description$f,
+	anyOf: anyOf$5
 };
 
+var $schema$e = "https://json-schema.org/draft/2020-12/schema";
+var $id$e = "https://schema.twindev.org/json-ld/JsonLdIndexMap";
+var description$e = "An index map allows keys that have no semantic meaning, but should be preserved regardless, to be used in JSON-LD documents.";
 var type$9 = "object";
 var additionalProperties$7 = {
 	anyOf: [
@@ -590,19 +783,26 @@ var additionalProperties$7 = {
 		},
 		{
 			type: "array",
-			items: {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdIndexMapItem"
-			}
+			items: false,
+			prefixItems: [
+				{
+					$ref: "https://schema.twindev.org/json-ld/JsonLdIndexMapItem"
+				}
+			]
 		}
 	]
 };
-var description$a = "An index map allows keys that have no semantic meaning, but should be preserved regardless, to be used in JSON-LD documents.";
 var JsonLdIndexMapSchema = {
+	$schema: $schema$e,
+	$id: $id$e,
+	description: description$e,
 	type: type$9,
-	additionalProperties: additionalProperties$7,
-	description: description$a
+	additionalProperties: additionalProperties$7
 };
 
+var $schema$d = "https://json-schema.org/draft/2020-12/schema";
+var $id$d = "https://schema.twindev.org/json-ld/JsonLdIndexMapItem";
+var description$d = "The items that can be stored in an index map.";
 var anyOf$4 = [
 	{
 		type: "null"
@@ -629,21 +829,35 @@ var anyOf$4 = [
 		$ref: "https://schema.twindev.org/json-ld/JsonLdSetObject"
 	}
 ];
-var description$9 = "The items that can be stored in an index map.";
 var JsonLdIndexMapItemSchema = {
-	anyOf: anyOf$4,
-	description: description$9
+	$schema: $schema$d,
+	$id: $id$d,
+	description: description$d,
+	anyOf: anyOf$4
 };
 
+var $schema$c = "https://json-schema.org/draft/2020-12/schema";
+var $id$c = "https://schema.twindev.org/json-ld/JsonLdJsonArray";
+var description$c = "JSON Type for array.";
 var type$8 = "array";
-var items = {
-	$ref: "https://schema.twindev.org/json-ld/JsonLdJsonValue"
-};
+var items = false;
+var prefixItems = [
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdJsonValue"
+	}
+];
 var JsonLdJsonArraySchema = {
+	$schema: $schema$c,
+	$id: $id$c,
+	description: description$c,
 	type: type$8,
-	items: items
+	items: items,
+	prefixItems: prefixItems
 };
 
+var $schema$b = "https://json-schema.org/draft/2020-12/schema";
+var $id$b = "https://schema.twindev.org/json-ld/JsonLdJsonObject";
+var description$b = "JSON Type for object.";
 var type$7 = "object";
 var additionalProperties$6 = {
 	anyOf: [
@@ -657,10 +871,16 @@ var additionalProperties$6 = {
 	]
 };
 var JsonLdJsonObjectSchema = {
+	$schema: $schema$b,
+	$id: $id$b,
+	description: description$b,
 	type: type$7,
 	additionalProperties: additionalProperties$6
 };
 
+var $schema$a = "https://json-schema.org/draft/2020-12/schema";
+var $id$a = "https://schema.twindev.org/json-ld/JsonLdJsonPrimitive";
+var description$a = "JSON Primitive.";
 var type$6 = [
 	"string",
 	"number",
@@ -668,9 +888,15 @@ var type$6 = [
 	"null"
 ];
 var JsonLdJsonPrimitiveSchema = {
+	$schema: $schema$a,
+	$id: $id$a,
+	description: description$a,
 	type: type$6
 };
 
+var $schema$9 = "https://json-schema.org/draft/2020-12/schema";
+var $id$9 = "https://schema.twindev.org/json-ld/JsonLdJsonValue";
+var description$9 = "JSON Value.";
 var anyOf$3 = [
 	{
 		$ref: "https://schema.twindev.org/json-ld/JsonLdJsonPrimitive"
@@ -683,281 +909,235 @@ var anyOf$3 = [
 	}
 ];
 var JsonLdJsonValueSchema = {
+	$schema: $schema$9,
+	$id: $id$9,
+	description: description$9,
 	anyOf: anyOf$3
 };
 
+var $schema$8 = "https://json-schema.org/draft/2020-12/schema";
+var $id$8 = "https://schema.twindev.org/json-ld/JsonLdLanguageMap";
+var description$8 = "A language map is used to associate a language with a value in a way that allows easy programmatic access.";
 var type$5 = "object";
-var properties$3 = {
-	"@base": {
-		type: [
-			"string",
-			"null"
-		]
-	},
-	"@container": {
-		anyOf: [
-			{
-				type: "string",
-				"const": "@list"
-			},
-			{
-				type: "string",
-				"const": "@set"
-			},
-			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdContainerType"
-			},
-			{
-				type: "array",
-				items: {
-					anyOf: [
-						{
-							type: "string",
-							"const": "@list"
-						},
-						{
-							type: "string",
-							"const": "@set"
-						},
-						{
-							$ref: "https://schema.twindev.org/json-ld/JsonLdContainerType"
-						}
-					]
-				}
-			},
-			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdContainerTypeArray"
-			},
-			{
-				type: "null"
-			}
-		]
-	},
-	"@context": {
-		$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
-	},
-	"@direction": {
-		type: [
-			"string",
-			"null"
-		],
-		"enum": [
-			"ltr",
-			"rtl",
-			null
-		]
-	},
-	"@graph": {
-		anyOf: [
-			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdValueObject"
-			},
-			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
-			},
-			{
-				type: "array",
-				items: {
-					anyOf: [
-						{
-							$ref: "https://schema.twindev.org/json-ld/JsonLdValueObject"
-						},
-						{
-							$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
-						}
-					]
+var additionalProperties$5 = {
+	anyOf: [
+		{
+			type: "null"
+		},
+		{
+			type: "string"
+		},
+		{
+			type: "array",
+			items: false,
+			prefixItems: [
+				{
+					type: "string"
 				}
-			}
-		]
-	},
-	"@id": {
+			]
+		}
+	]
+};
+var JsonLdLanguageMapSchema = {
+	$schema: $schema$8,
+	$id: $id$8,
+	description: description$8,
+	type: type$5,
+	additionalProperties: additionalProperties$5
+};
+
+var $schema$7 = "https://json-schema.org/draft/2020-12/schema";
+var $id$7 = "https://schema.twindev.org/json-ld/JsonLdListObject";
+var description$7 = "A list represents an ordered set of values.";
+var type$4 = "object";
+var properties$3 = {
+	"@list": {
 		anyOf: [
 			{
-				type: "string"
+				$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
 			},
 			{
 				type: "array",
-				items: {
-					type: "string"
-				}
+				items: false,
+				prefixItems: [
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
+					}
+				]
 			}
 		]
 	},
-	"@import": {
-		type: "string"
-	},
-	"@included": {
-		$ref: "https://schema.twindev.org/json-ld/JsonLdIncludedBlock"
-	},
 	"@index": {
 		type: "string"
+	}
+};
+var required$1 = [
+	"@list"
+];
+var additionalProperties$4 = false;
+var JsonLdListObjectSchema = {
+	$schema: $schema$7,
+	$id: $id$7,
+	description: description$7,
+	type: type$4,
+	properties: properties$3,
+	required: required$1,
+	additionalProperties: additionalProperties$4
+};
+
+var $schema$6 = "https://json-schema.org/draft/2020-12/schema";
+var $id$6 = "https://schema.twindev.org/json-ld/JsonLdListOrSetItem";
+var description$6 = "A list or set item can be a null, boolean, number, string, node object, or value object.";
+var anyOf$2 = [
+	{
+		type: "null"
 	},
-	"@json": {
-		type: "string",
-		"const": "@json"
+	{
+		type: "boolean"
 	},
-	"@language": {
+	{
+		type: "number"
+	},
+	{
 		type: "string"
 	},
-	"@list": {
-		anyOf: [
-			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
-			},
-			{
-				type: "array",
-				items: {
-					$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
-				}
-			}
-		]
-	},
-	"@nest": {
-		type: "object"
-	},
-	"@none": {
-		type: "string",
-		"const": "@none"
-	},
-	"@prefix": {
-		type: "boolean"
-	},
-	"@propagate": {
-		type: "boolean"
-	},
-	"@protected": {
-		type: "boolean"
-	},
-	"@reverse": {
-		type: "string"
-	},
-	"@set": {
-		anyOf: [
-			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
-			},
-			{
-				type: "array",
-				items: {
-					$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
-				}
-			}
-		]
-	},
-	"@type": {
-		type: "string"
-	},
-	"@value": {
-		type: [
-			"null",
-			"boolean",
-			"number",
-			"string"
-		]
-	},
-	"@version": {
-		type: "string",
-		"const": "1.1"
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
 	},
-	"@vocab": {
-		type: [
-			"string",
-			"null"
-		]
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdValueObject"
 	}
-};
-var required$2 = [
-	"@base",
-	"@container",
-	"@context",
-	"@direction",
-	"@graph",
-	"@id",
-	"@import",
-	"@included",
-	"@index",
-	"@json",
-	"@language",
-	"@list",
-	"@nest",
-	"@none",
-	"@prefix",
-	"@propagate",
-	"@protected",
-	"@reverse",
-	"@set",
-	"@type",
-	"@value",
-	"@version",
-	"@vocab"
 ];
-var additionalProperties$5 = false;
-var description$8 = "A list of keywords and their types. Only used for internal reference; not an actual interface. Not for export.";
-var JsonLdKeywordSchema = {
-	type: type$5,
-	properties: properties$3,
-	required: required$2,
-	additionalProperties: additionalProperties$5,
-	description: description$8
+var JsonLdListOrSetItemSchema = {
+	$schema: $schema$6,
+	$id: $id$6,
+	description: description$6,
+	anyOf: anyOf$2
 };
 
-var type$4 = "object";
-var additionalProperties$4 = {
+var $schema$5 = "https://json-schema.org/draft/2020-12/schema";
+var $id$5 = "https://schema.twindev.org/json-ld/JsonLdNodeObject";
+var description$5 = "A node object represents zero or more properties of a node in the graph serialized by the JSON-LD document.";
+var type$3 = "object";
+var additionalProperties$3 = {
 	anyOf: [
 		{
-			type: "null"
+			$ref: "https://schema.twindev.org/json-ld/JsonLdNodePrimitive"
 		},
 		{
-			type: "string"
+			$ref: "https://schema.twindev.org/json-ld/JsonLdLanguageMap"
 		},
 		{
-			type: "array",
-			items: {
-				type: "string"
-			}
+			$ref: "https://schema.twindev.org/json-ld/JsonLdIndexMap"
+		},
+		{
+			$ref: "https://schema.twindev.org/json-ld/JsonLdIncludedBlock"
+		},
+		{
+			$ref: "https://schema.twindev.org/json-ld/JsonLdIdMap"
+		},
+		{
+			$ref: "https://schema.twindev.org/json-ld/JsonLdTypeMap"
+		},
+		{
+			type: "array"
 		}
 	]
 };
-var description$7 = "A language map is used to associate a language with a value in a way that allows easy programmatic access.";
-var JsonLdLanguageMapSchema = {
-	type: type$4,
-	additionalProperties: additionalProperties$4,
-	description: description$7
-};
-
-var type$3 = "object";
 var properties$2 = {
-	"@list": {
+	"@context": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
+	},
+	"@id": {
 		anyOf: [
 			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
+				type: "string"
 			},
 			{
 				type: "array",
-				items: {
-					$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
-				}
+				items: false,
+				prefixItems: [
+					{
+						type: "string"
+					}
+				]
+			}
+		]
+	},
+	"@included": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdIncludedBlock"
+	},
+	"@graph": {
+		anyOf: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+			},
+			{
+				type: "array",
+				items: false,
+				prefixItems: [
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+					}
+				]
+			}
+		]
+	},
+	"@nest": {
+		anyOf: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdJsonObject"
+			},
+			{
+				type: "array",
+				items: false,
+				prefixItems: [
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdJsonObject"
+					}
+				]
 			}
 		]
 	},
+	"@type": {
+		anyOf: [
+			{
+				type: "string"
+			},
+			{
+				type: "array",
+				items: false,
+				prefixItems: [
+					{
+						type: "string"
+					}
+				]
+			}
+		]
+	},
+	"@reverse": {
+		type: "object",
+		additionalProperties: {
+			type: "string"
+		}
+	},
 	"@index": {
 		type: "string"
 	}
 };
-var required$1 = [
-	"@list"
-];
-var additionalProperties$3 = false;
-var description$6 = "A list represents an ordered set of values.";
-var JsonLdListObjectSchema = {
+var JsonLdNodeObjectSchema = {
+	$schema: $schema$5,
+	$id: $id$5,
+	description: description$5,
 	type: type$3,
-	properties: properties$2,
-	required: required$1,
 	additionalProperties: additionalProperties$3,
-	description: description$6
+	properties: properties$2
 };
 
-var anyOf$2 = [
+var $schema$4 = "https://json-schema.org/draft/2020-12/schema";
+var $id$4 = "https://schema.twindev.org/json-ld/JsonLdNodePrimitive";
+var description$4 = "A node primitive is a JSON-LD value which is not one of the defined NodeObject properties.";
+var anyOf$1 = [
 	{
 		type: "null"
 	},
@@ -973,16 +1153,29 @@ var anyOf$2 = [
 	{
 		$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
 	},
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdGraphObject"
+	},
 	{
 		$ref: "https://schema.twindev.org/json-ld/JsonLdValueObject"
+	},
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdListObject"
+	},
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdSetObject"
 	}
 ];
-var description$5 = "A list or set item can be a null, boolean, number, string, node object, or value object.";
-var JsonLdListOrSetItemSchema = {
-	anyOf: anyOf$2,
-	description: description$5
+var JsonLdNodePrimitiveSchema = {
+	$schema: $schema$4,
+	$id: $id$4,
+	description: description$4,
+	anyOf: anyOf$1
 };
 
+var $schema$3 = "https://json-schema.org/draft/2020-12/schema";
+var $id$3 = "https://schema.twindev.org/json-ld/JsonLdObject";
+var description$3 = "An object represents the pre-defined properties of the node object in the graph serialized by the JSON-LD document.";
 var type$2 = "object";
 var properties$1 = {
 	"@context": {
@@ -995,9 +1188,12 @@ var properties$1 = {
 			},
 			{
 				type: "array",
-				items: {
-					type: "string"
-				}
+				items: false,
+				prefixItems: [
+					{
+						type: "string"
+					}
+				]
 			}
 		]
 	},
@@ -1011,9 +1207,12 @@ var properties$1 = {
 			},
 			{
 				type: "array",
-				items: {
-					$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
-				}
+				items: false,
+				prefixItems: [
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+					}
+				]
 			}
 		]
 	},
@@ -1024,9 +1223,12 @@ var properties$1 = {
 			},
 			{
 				type: "array",
-				items: {
-					$ref: "https://schema.twindev.org/json-ld/JsonLdJsonObject"
-				}
+				items: false,
+				prefixItems: [
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdJsonObject"
+					}
+				]
 			}
 		]
 	},
@@ -1037,9 +1239,12 @@ var properties$1 = {
 			},
 			{
 				type: "array",
-				items: {
-					type: "string"
-				}
+				items: false,
+				prefixItems: [
+					{
+						type: "string"
+					}
+				]
 			}
 		]
 	},
@@ -1053,77 +1258,19 @@ var properties$1 = {
 		type: "string"
 	}
 };
-var additionalProperties$2 = {
-	anyOf: [
-		{
-			$ref: "https://schema.twindev.org/json-ld/JsonLdNodePrimitive"
-		},
-		{
-			type: "array",
-			items: {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdNodePrimitive"
-			}
-		},
-		{
-			$ref: "https://schema.twindev.org/json-ld/JsonLdLanguageMap"
-		},
-		{
-			$ref: "https://schema.twindev.org/json-ld/JsonLdIndexMap"
-		},
-		{
-			$ref: "https://schema.twindev.org/json-ld/JsonLdIncludedBlock"
-		},
-		{
-			$ref: "https://schema.twindev.org/json-ld/JsonLdIdMap"
-		},
-		{
-			$ref: "https://schema.twindev.org/json-ld/JsonLdTypeMap"
-		}
-	]
-};
-var description$4 = "A node object represents zero or more properties of a node in the graph serialized by the JSON-LD document.";
-var JsonLdNodeObjectSchema = {
+var additionalProperties$2 = false;
+var JsonLdObjectSchema = {
+	$schema: $schema$3,
+	$id: $id$3,
+	description: description$3,
 	type: type$2,
 	properties: properties$1,
-	additionalProperties: additionalProperties$2,
-	description: description$4
-};
-
-var anyOf$1 = [
-	{
-		type: "null"
-	},
-	{
-		type: "boolean"
-	},
-	{
-		type: "number"
-	},
-	{
-		type: "string"
-	},
-	{
-		$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
-	},
-	{
-		$ref: "https://schema.twindev.org/json-ld/JsonLdGraphObject"
-	},
-	{
-		$ref: "https://schema.twindev.org/json-ld/JsonLdValueObject"
-	},
-	{
-		$ref: "https://schema.twindev.org/json-ld/JsonLdListObject"
-	},
-	{
-		$ref: "https://schema.twindev.org/json-ld/JsonLdSetObject"
-	}
-];
-var description$3 = "A node primitive is a JSON-LD value which is not one of the defined NodeObject properties.";
-var JsonLdNodePrimitiveSchema = {
-	anyOf: anyOf$1,
-	description: description$3
+	additionalProperties: additionalProperties$2
 };
 
+var $schema$2 = "https://json-schema.org/draft/2020-12/schema";
+var $id$2 = "https://schema.twindev.org/json-ld/JsonLdSetObject";
+var description$2 = "A set represents an unordered set of values.";
 var type$1 = "object";
 var properties = {
 	"@set": {
@@ -1133,9 +1280,12 @@ var properties = {
 			},
 			{
 				type: "array",
-				items: {
-					$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
-				}
+				items: false,
+				prefixItems: [
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
+					}
+				]
 			}
 		]
 	},
@@ -1147,15 +1297,19 @@ var required = [
 	"@set"
 ];
 var additionalProperties$1 = false;
-var description$2 = "A set represents an unordered set of values.";
 var JsonLdSetObjectSchema = {
+	$schema: $schema$2,
+	$id: $id$2,
+	description: description$2,
 	type: type$1,
 	properties: properties,
 	required: required,
-	additionalProperties: additionalProperties$1,
-	description: description$2
+	additionalProperties: additionalProperties$1
 };
 
+var $schema$1 = "https://json-schema.org/draft/2020-12/schema";
+var $id$1 = "https://schema.twindev.org/json-ld/JsonLdTypeMap";
+var description$1 = "A type map is used to associate an IRI with a value that allows easy programmatic access.";
 var type = "object";
 var additionalProperties = {
 	anyOf: [
@@ -1167,32 +1321,49 @@ var additionalProperties = {
 		}
 	]
 };
-var description$1 = "A type map is used to associate an IRI with a value that allows easy programmatic access.";
 var JsonLdTypeMapSchema = {
+	$schema: $schema$1,
+	$id: $id$1,
+	description: description$1,
 	type: type,
-	additionalProperties: additionalProperties,
-	description: description$1
+	additionalProperties: additionalProperties
 };
 
+var $schema = "https://json-schema.org/draft/2020-12/schema";
+var $id = "https://schema.twindev.org/json-ld/JsonLdValueObject";
+var description = "A value object is used to explicitly associate a type or a language with a value to create a typed value or a language-tagged string and possibly associate a base direction.";
 var anyOf = [
 	{
 		type: "object",
 		additionalProperties: false,
 		properties: {
 			"@value": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: [
+					"null",
+					"boolean",
+					"number",
+					"string"
+				]
 			},
 			"@language": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "string"
 			},
 			"@direction": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: [
+					"string",
+					"null"
+				],
+				"enum": [
+					"ltr",
+					"rtl",
+					null
+				]
 			},
 			"@index": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "string"
 			},
 			"@context": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
 			}
 		},
 		required: [
@@ -1204,16 +1375,21 @@ var anyOf = [
 		additionalProperties: false,
 		properties: {
 			"@value": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: [
+					"null",
+					"boolean",
+					"number",
+					"string"
+				]
 			},
 			"@type": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "string"
 			},
 			"@index": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "string"
 			},
 			"@context": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
 			}
 		},
 		required: [
@@ -1228,7 +1404,16 @@ var anyOf = [
 			"@value": {
 				anyOf: [
 					{
-						$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+						type: "null"
+					},
+					{
+						type: "boolean"
+					},
+					{
+						type: "number"
+					},
+					{
+						type: "string"
 					},
 					{
 						$ref: "https://schema.twindev.org/json-ld/JsonLdJsonObject"
@@ -1243,10 +1428,10 @@ var anyOf = [
 				"const": "@json"
 			},
 			"@index": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "string"
 			},
 			"@context": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
 			}
 		},
 		required: [
@@ -1255,10 +1440,11 @@ var anyOf = [
 		]
 	}
 ];
-var description = "A value object is used to explicitly associate a type or a language with a value to create a typed value or a language-tagged string and possibly associate a base direction.";
 var JsonLdValueObjectSchema = {
-	anyOf: anyOf,
-	description: description
+	$schema: $schema,
+	$id: $id,
+	description: description,
+	anyOf: anyOf
 };
 
 // Copyright 2024 IOTA Stiftung.
@@ -1271,142 +1457,139 @@ class JsonLdDataTypes {
      * Register all the data types.
      */
     static registerTypes() {
-        DataTypeHandlerFactory.register(JsonLdTypes.Document, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.Document}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.Document,
             jsonSchema: async () => JsonLdDocumentSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.NodeObject, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.Object}`, () => ({
+            context: JsonLdContexts.ContextRoot,
+            type: JsonLdTypes.Object,
+            jsonSchema: async () => JsonLdObjectSchema
+        }));
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.NodeObject}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.NodeObject,
             jsonSchema: async () => JsonLdNodeObjectSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.NodePrimitive, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.NodePrimitive}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.NodePrimitive,
             jsonSchema: async () => JsonLdNodePrimitiveSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.GraphObject, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.GraphObject}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.GraphObject,
             jsonSchema: async () => JsonLdGraphObjectSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.ValueObject, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ValueObject}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.ValueObject,
             jsonSchema: async () => JsonLdValueObjectSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.ListObject, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ListObject}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.ListObject,
             jsonSchema: async () => JsonLdListObjectSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.ListObject, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ListObject}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.ListObject,
             jsonSchema: async () => JsonLdListObjectSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.SetObject, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.SetObject}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.SetObject,
             jsonSchema: async () => JsonLdSetObjectSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.LanguageMap, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.LanguageMap}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.LanguageMap,
             jsonSchema: async () => JsonLdLanguageMapSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.IndexMap, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.IndexMap}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.IndexMap,
             jsonSchema: async () => JsonLdIndexMapSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.IndexMapItem, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.IndexMapItem}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.IndexMapItem,
             jsonSchema: async () => JsonLdIndexMapItemSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.IdMap, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.IdMap}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.IdMap,
             jsonSchema: async () => JsonLdIdMapSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.TypeMap, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.TypeMap}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.TypeMap,
             jsonSchema: async () => JsonLdTypeMapSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.IncludedBlock, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.IncludedBlock}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.IncludedBlock,
             jsonSchema: async () => JsonLdIncludedBlockSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.ContextDefinition, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ContextDefinition}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.ContextDefinition,
             jsonSchema: async () => JsonLdContextDefinitionSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.ExpandedTermDefinition, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ContextDefinitionElement}`, () => ({
+            context: JsonLdContexts.ContextRoot,
+            type: JsonLdTypes.ContextDefinitionElement,
+            jsonSchema: async () => JsonLdContextDefinitionElementSchema
+        }));
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ContextDefinitionRoot}`, () => ({
+            context: JsonLdContexts.ContextRoot,
+            type: JsonLdTypes.ContextDefinitionRoot,
+            jsonSchema: async () => JsonLdContextDefinitionRootSchema
+        }));
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ExpandedTermDefinition}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.ExpandedTermDefinition,
             jsonSchema: async () => JsonLdExpandedTermDefinitionSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.Keyword, () => ({
-            type: JsonLdTypes.Keyword,
-            jsonSchema: async () => JsonLdKeywordSchema
-        }));
-        DataTypeHandlerFactory.register(JsonLdTypes.ListOrSetItem, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ListOrSetItem}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.ListOrSetItem,
             jsonSchema: async () => JsonLdListOrSetItemSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.ContainerType, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ContainerType}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.ContainerType,
             jsonSchema: async () => JsonLdContainerTypeSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.ContainerTypeArray, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ContainerTypeArray}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.ContainerTypeArray,
             jsonSchema: async () => JsonLdContainerTypeArraySchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.JsonPrimitive, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.JsonPrimitive}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.JsonPrimitive,
             jsonSchema: async () => JsonLdJsonPrimitiveSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.JsonArray, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.JsonArray}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.JsonArray,
             jsonSchema: async () => JsonLdJsonArraySchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.JsonObject, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.JsonObject}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.JsonObject,
             jsonSchema: async () => JsonLdJsonObjectSchema
         }));
-        DataTypeHandlerFactory.register(JsonLdTypes.JsonValue, () => ({
+        DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.JsonValue}`, () => ({
+            context: JsonLdContexts.ContextRoot,
             type: JsonLdTypes.JsonValue,
             jsonSchema: async () => JsonLdJsonValueSchema
         }));
     }
 }
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class to help with JSON LD.
- */
-class JsonLdHelper {
-    /**
-     * Validate a JSON-LD document.
-     * @param document The JSON-LD document to validate.
-     * @param validationFailures The list of validation failures to add to.
-     * @param validationMode The validation mode to use, defaults to either.
-     * @returns True if the document was valid.
-     */
-    static async validate(document, validationFailures, validationMode) {
-        if (Is.array(document)) {
-            // If the document is an array of nodes, validate each node
-            for (const node of document) {
-                await JsonLdHelper.validate(node, validationFailures, validationMode);
-            }
-        }
-        else if (Is.array(document["@graph"])) {
-            // If the graph is an array of nodes, validate each node
-            for (const node of document["@graph"]) {
-                await JsonLdHelper.validate(node, validationFailures, validationMode);
-            }
-        }
-        else if (Is.object(document)) {
-            // If the graph is a single node, then use the validate the node schema
-            const dataType = document["@type"];
-            if (Is.stringValue(dataType)) {
-                await DataTypeHelper.validate("document", dataType, document, validationFailures, validationMode);
-            }
-        }
-        return validationFailures.length === 0;
-    }
-}
-
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -1419,49 +1602,112 @@ class JsonLdProcessor {
      */
     static _CLASS_NAME = "JsonLdProcessor";
     /**
-     * Redirects to use during document resolution.
+     * The document loader to use.
+     * @param documentLoader The document loader to use.
      */
-    static _redirects = [];
+    static setDocumentLoader(documentLoader) {
+        SharedStore.set("jsonLdDocumentLoader", documentLoader);
+    }
     /**
-     * The document loader to use.
+     * The document loader to use for retrieving JSON-LD documents.
+     * @returns The document loader.
+     */
+    static getDocumentLoader() {
+        let documentLoader = SharedStore.get("jsonLdDocumentLoader");
+        if (Is.empty(documentLoader)) {
+            documentLoader = async (url) => JsonLdProcessor.documentLoader(url);
+        }
+        return documentLoader;
+    }
+    /**
+     * Set the cache time limit for documents.
+     * @param cacheLimitMs The cache limit in milliseconds.
+     */
+    static setCacheLimit(cacheLimitMs) {
+        SharedStore.set("jsonLdDocumentCacheLimit", cacheLimitMs);
+    }
+    /**
+     * Get the cache limit for documents.
+     * @returns The document loader.
+     */
+    static getCacheLimit() {
+        let cacheLimitMs = SharedStore.get("jsonLdDocumentCacheLimit");
+        if (Is.empty(cacheLimitMs)) {
+            cacheLimitMs = 3600000;
+            SharedStore.set("jsonLdDocumentCacheLimit", cacheLimitMs);
+        }
+        return cacheLimitMs;
+    }
+    /**
+     * Set the global redirects for JSON-LD, use addRedirect for default handling.
+     * @param redirects The redirects to use.
+     */
+    static setRedirects(redirects) {
+        SharedStore.set("jsonLdRedirects", redirects);
+    }
+    /**
+     * Get the global redirects for JSON-LD.
+     * @returns The registered redirects.
      */
-    static DOCUMENT_LOADER = async (url) => JsonLdProcessor.documentLoader(url);
+    static getRedirects() {
+        let redirects = SharedStore.get("jsonLdRedirects");
+        if (Is.empty(redirects)) {
+            redirects = [];
+            SharedStore.set("jsonLdRedirects", redirects);
+        }
+        return redirects;
+    }
     /**
      * Compact a document according to a particular context.
      * @param document The JSON-LD document to compact.
-     * @param context The context to compact the document to, if not provided will try and gather from the object.
+     * @param context The context to compact the document to, if not provided will use the one in the document.
+     * @param options The options for compacting the document.
+     * @param options.itemListOverride Whether to override the itemListElement context with a set, defaults to true.
      * @returns The compacted JSON-LD document.
      */
-    static async compact(document, context) {
+    static async compact(document, context, options) {
         try {
-            // There is a cast here because the jsonld types are not correct.
-            // A context definition can be an array or an object, but the types only allow an object.
-            if (Is.empty(context)) {
-                context = {};
-                if (Is.array(document)) {
-                    for (const node of document) {
-                        context = JsonLdProcessor.gatherContexts(node, context);
-                    }
+            if (Is.object(document)) {
+                // If the user didn't provide a context, use the one from the document
+                if (Is.empty(context) && !Is.empty(document["@context"])) {
+                    context = document["@context"];
                 }
-                else if (Is.array(document["@graph"])) {
-                    for (const node of document["@graph"]) {
-                        context = JsonLdProcessor.gatherContexts(node, context);
+                const overrideListElementOption = options?.itemListOverride ?? true;
+                let overrideContext;
+                if (overrideListElementOption) {
+                    // The compactArrays flag doesn't work with the current version of jsonld.js
+                    // For list results we standardise on ItemList and itemListElement
+                    // so we modify the schema.org type for itemListElement to be a set which bypasses the issue
+                    // https://github.com/digitalbazaar/jsonld.js/issues/247
+                    overrideContext = {
+                        itemListElement: {
+                            "@id": "http://schema.org/itemListElement",
+                            "@container": "@set",
+                            "@protected": true
+                        }
+                    };
+                    if (Is.object(context) && "@context" in context) {
+                        // If the context is an object, we need to merge it with the override context
+                        context = JsonLdProcessor.combineContexts(context["@context"], overrideContext);
+                    }
+                    else {
+                        // If the context is a string or an array, we need to merge it with the override context
+                        context = JsonLdProcessor.combineContexts(context, overrideContext);
                     }
                 }
-                else if (Is.object(document)) {
-                    context = JsonLdProcessor.gatherContexts(document, context);
+                const compacted = await jsonLd.compact(ObjectHelper.removeEmptyProperties(document), context, {
+                    documentLoader: JsonLdProcessor.getDocumentLoader()
+                });
+                if (!Is.empty(overrideContext)) {
+                    // Remove the override context from the compacted document
+                    compacted["@context"] = JsonLdProcessor.removeContexts(compacted["@context"], [overrideContext]);
                 }
+                return compacted;
             }
-            const compacted = await jsonLd.compact(document, context, {
-                documentLoader: JsonLdProcessor.DOCUMENT_LOADER
-            });
-            return compacted;
+            return document;
         }
         catch (err) {
-            if (Is.object(err) &&
-                err.name === "jsonld.InvalidUrl") {
-                throw new GeneralError(JsonLdProcessor._CLASS_NAME, "invalidUrl", { url: err.details?.url }, err);
-            }
+            JsonLdProcessor.handleCommonErrors(err);
             throw new GeneralError(JsonLdProcessor._CLASS_NAME, "compact", undefined, err);
         }
     }
@@ -1472,45 +1718,50 @@ class JsonLdProcessor {
      */
     static async expand(compacted) {
         try {
-            const expanded = await jsonLd.expand(compacted, {
-                documentLoader: JsonLdProcessor.DOCUMENT_LOADER
-            });
-            return expanded;
+            if (Is.object(compacted)) {
+                const expanded = await jsonLd.expand(ObjectHelper.removeEmptyProperties(compacted), {
+                    documentLoader: JsonLdProcessor.getDocumentLoader()
+                });
+                return expanded;
+            }
+            return [];
         }
         catch (err) {
-            if (Is.object(err) &&
-                err.name === "jsonld.InvalidUrl") {
-                throw new GeneralError(JsonLdProcessor._CLASS_NAME, "invalidUrl", { url: err.details?.url }, err);
-            }
+            JsonLdProcessor.handleCommonErrors(err);
             throw new GeneralError(JsonLdProcessor._CLASS_NAME, "expand", undefined, err);
         }
     }
     /**
-     * Add a redirect to use during document resolution.
-     * @param from The URL to redirect from.
-     * @param to The URL to redirect to.
+     * Canonize a document.
+     * @param document The document to canonize.
+     * @param options The options for canonization.
+     * @param options.algorithm The algorithm to use for canonization, defaults to URDNA2015.
+     * @returns The canonized document.
      */
-    static addRedirect(from, to) {
-        if (!this._redirects.some(r => r.from === from)) {
-            this._redirects.push({ from, to });
+    static async canonize(document, options) {
+        try {
+            const normalized = await jsonLd.canonize(ObjectHelper.removeEmptyProperties(document), {
+                algorithm: options?.algorithm ?? "URDNA2015",
+                format: "application/n-quads",
+                documentLoader: JsonLdProcessor.getDocumentLoader()
+            });
+            return normalized;
+        }
+        catch (err) {
+            JsonLdProcessor.handleCommonErrors(err);
+            throw new GeneralError(JsonLdProcessor._CLASS_NAME, "canonize", undefined, err);
         }
     }
     /**
-     * Extract a property from the JSON-LD.
-     * @param nodeObject The JSON-LD node object to extract from.
-     * @param propertyNames The possible names for the property.
-     * @param deleteProperty Delete the property from the object, defaults to true.
-     * @returns The properties if available.
+     * Add a redirect to use during document resolution.
+     * @param from The URL to redirect from.
+     * @param to The URL to redirect to.
      */
-    static extractProperty(nodeObject, propertyNames, deleteProperty = true) {
-        let retVal;
-        for (const prop of propertyNames) {
-            retVal ??= nodeObject[prop];
-            if (deleteProperty) {
-                delete nodeObject[prop];
-            }
+    static addRedirect(from, to) {
+        const redirects = JsonLdProcessor.getRedirects();
+        if (!redirects.some(r => r.from === from)) {
+            redirects.push({ from, to });
         }
-        return retVal;
     }
     /**
      * Combine contexts.
@@ -1574,18 +1825,20 @@ class JsonLdProcessor {
      */
     static gatherContexts(element, initial) {
         let combinedContexts = initial;
-        if (!Is.empty(element["@context"])) {
-            combinedContexts = JsonLdProcessor.combineContexts(initial, element["@context"]);
-        }
-        for (const prop of Object.keys(element)) {
-            const value = element[prop];
-            if (Is.object(value)) {
-                combinedContexts = this.gatherContexts(value, combinedContexts);
+        if (Is.object(element)) {
+            if (!Is.empty(element["@context"])) {
+                combinedContexts = JsonLdProcessor.combineContexts(initial, element["@context"]);
             }
-            else if (Is.array(value)) {
-                for (const item of value) {
-                    if (Is.object(item)) {
-                        combinedContexts = this.gatherContexts(item, combinedContexts);
+            for (const prop of Object.keys(element)) {
+                const value = element[prop];
+                if (Is.object(value)) {
+                    combinedContexts = this.gatherContexts(value, combinedContexts);
+                }
+                else if (Is.array(value)) {
+                    for (const item of value) {
+                        if (Is.object(item)) {
+                            combinedContexts = this.gatherContexts(item, combinedContexts);
+                        }
                     }
                 }
             }
@@ -1631,6 +1884,23 @@ class JsonLdProcessor {
             ? finalContext[0]
             : finalContext;
     }
+    /**
+     * Add a context directly to the document loader cache.
+     * @param url The url the ld context is for.
+     * @param ldContext The context to add.
+     * @returns Nothing.
+     */
+    static async documentCacheAdd(url, ldContext) {
+        await FetchHelper.setCacheEntry(url, ldContext);
+    }
+    /**
+     * Remove a context from the document loader cache.
+     * @param url The url the ld context is for.
+     * @returns Nothing.
+     */
+    static async documentCacheRemove(url) {
+        await FetchHelper.removeCacheEntry(url);
+    }
     /**
      * Document loader which uses a caching mechanism.
      * @param url The document url to load.
@@ -1638,24 +1908,104 @@ class JsonLdProcessor {
      * @internal
      */
     static async documentLoader(url) {
-        for (const redirect of JsonLdProcessor._redirects) {
+        const redirects = JsonLdProcessor.getRedirects();
+        for (const redirect of redirects) {
             if (redirect.from.test(url)) {
                 url = redirect.to;
                 break;
             }
         }
-        // Cache the results for an hour
-        const response = await FetchHelper.fetchJson(JsonLdProcessor._CLASS_NAME, url, HttpMethod.GET, undefined, {
-            cacheTtlMs: 3600000,
-            headers: {
-                Accept: `${MimeTypes.JsonLd},${MimeTypes.Json}`
+        try {
+            const response = await FetchHelper.fetchJson(JsonLdProcessor._CLASS_NAME, url, HttpMethod.GET, undefined, {
+                cacheTtlMs: JsonLdProcessor.getCacheLimit(),
+                headers: {
+                    [HeaderTypes.Accept]: MimeTypes.JsonLd
+                }
+            });
+            return {
+                documentUrl: url,
+                document: response
+            };
+        }
+        catch (err) {
+            const error = BaseError.fromError(err);
+            if (error.message.includes("is not valid JSON")) {
+                const response = await FetchHelper.fetchJson(JsonLdProcessor._CLASS_NAME, url, HttpMethod.GET, undefined, {
+                    cacheTtlMs: JsonLdProcessor.getCacheLimit(),
+                    headers: {
+                        [HeaderTypes.Accept]: MimeTypes.Json
+                    }
+                });
+                return {
+                    documentUrl: url,
+                    document: response
+                };
+            }
+            throw err;
+        }
+    }
+    /**
+     * Handle common errors.
+     * @param err The error to handle.
+     * @internal
+     */
+    static handleCommonErrors(err) {
+        if (Is.object(err) &&
+            err.name === "jsonld.InvalidUrl") {
+            throw new GeneralError(JsonLdProcessor._CLASS_NAME, "invalidUrl", { url: err.details?.url }, err);
+        }
+        else if (Is.object(err) &&
+            err.name.startsWith("jsonld.")) {
+            throw new GeneralError(JsonLdProcessor._CLASS_NAME, "jsonLdError", err.details, err);
+        }
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class to help with JSON LD.
+ */
+class JsonLdHelper {
+    /**
+     * Validate a JSON-LD document.
+     * @param document The JSON-LD document to validate.
+     * @param validationFailures The list of validation failures to add to.
+     * @param options Optional options for validation.
+     * @param options.failOnMissingType If true, will fail validation if the data type is missing, defaults to false.
+     * @param options.validationMode The validation mode to use, defaults to either.
+     * @returns True if the document was valid.
+     */
+    static async validate(document, validationFailures, options) {
+        if (Is.array(document)) {
+            // If the document is an array of nodes, validate each node
+            for (const node of document) {
+                await JsonLdHelper.validate(node, validationFailures, options);
+            }
+        }
+        else if (Is.array(document["@graph"])) {
+            // If the graph is an array of nodes, validate each node
+            for (const node of document["@graph"]) {
+                await JsonLdHelper.validate(node, validationFailures, options);
+            }
+        }
+        else if (Is.object(document)) {
+            // Expand the document to ensure we have the full context for types
+            // As the data types in the factories are always fully qualified
+            const expandedDocs = await JsonLdProcessor.expand(document);
+            if (Is.arrayValue(expandedDocs)) {
+                for (const expandedDoc of expandedDocs) {
+                    const expandedDataTypes = ArrayHelper.fromObjectOrArray(expandedDoc["@type"]);
+                    if (Is.arrayValue(expandedDataTypes)) {
+                        for (const expandedDataType of expandedDataTypes) {
+                            await DataTypeHelper.validate("document", expandedDataType, document, validationFailures, options);
+                        }
+                    }
+                }
             }
-        });
-        return {
-            documentUrl: url,
-            document: response
-        };
+        }
+        return validationFailures.length === 0;
     }
 }
 
-export { JsonLdDataTypes, JsonLdHelper, JsonLdProcessor, JsonLdTypes };
+export { JsonLdContexts, JsonLdDataTypes, JsonLdHelper, JsonLdProcessor, JsonLdTypes };