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

package/dist/cjs/index.cjs

@@ -5,6 +5,19 @@ var core = require('@twin.org/core');
 var web = require('@twin.org/web');
 var jsonLd = require('jsonld');
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * The contexts of JSON-LD data.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const JsonLdContexts = {
+    /**
+     * Context Root.
+     */
+    ContextRoot: "https://schema.twindev.org/json-ld/"
+};
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
@@ -15,107 +28,113 @@ 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 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 type$d = "string";
+var type$e = "string";
+var description$n = "Helper Types";
 var JsonLdContainerTypeSchema = {
-	type: type$d,
+	type: type$e,
 	"enum": [
 	"@language",
 	"@index",
 	"@id",
 	"@graph",
 	"@type"
-]
+],
+	description: description$n
 };
 
 var anyOf$8 = [
@@ -292,29 +311,42 @@ var anyOf$8 = [
 		maxItems: 2
 	}
 ];
+var description$m = "Helper Types.";
 var JsonLdContainerTypeArraySchema = {
-	anyOf: anyOf$8
+	anyOf: anyOf$8,
+	description: description$m
 };
 
-var type$c = "object";
-var properties$5 = {
+var type$d = "object";
+var properties$6 = {
 	"@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",
@@ -324,7 +356,7 @@ var properties$5 = {
 				"const": "@set"
 			},
 			"@protected": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "boolean"
 			}
 		},
 		required: [
@@ -333,13 +365,17 @@ 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 = {
+var additionalProperties$b = {
 	anyOf: [
 		{
 			type: "null"
@@ -352,12 +388,12 @@ var additionalProperties$a = {
 		}
 	]
 };
-var description$g = "A context definition defines a local context in a node object.";
+var description$l = "A context definition defines a local context in a node object.";
 var JsonLdContextDefinitionSchema = {
-	type: type$c,
-	properties: properties$5,
-	additionalProperties: additionalProperties$a,
-	description: description$g
+	type: type$d,
+	properties: properties$6,
+	additionalProperties: additionalProperties$b,
+	description: description$l
 };
 
 var anyOf$7 = [
@@ -374,33 +410,7 @@ var anyOf$7 = [
 		type: "object",
 		properties: {
 			"@context": {
-				anyOf: [
-					{
-						type: "null"
-					},
-					{
-						type: "string"
-					},
-					{
-						$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
-					},
-					{
-						type: "array",
-						items: {
-							anyOf: [
-								{
-									type: "null"
-								},
-								{
-									type: "string"
-								},
-								{
-									$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
-								}
-							]
-						}
-					}
-				]
+				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
 			},
 			"@graph": {
 				anyOf: [
@@ -429,10 +439,10 @@ 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 description$k = "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
+	description: description$k
 };
 
 var anyOf$6 = [
@@ -443,7 +453,13 @@ var anyOf$6 = [
 			"@id": {
 				anyOf: [
 					{
-						$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+						type: "string"
+					},
+					{
+						type: "array",
+						items: {
+							type: "string"
+						}
 					},
 					{
 						type: "null"
@@ -454,28 +470,64 @@ 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: {
+							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"
 			}
 		}
 	},
@@ -484,7 +536,7 @@ var anyOf$6 = [
 		additionalProperties: false,
 		properties: {
 			"@reverse": {
-				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				type: "string"
 			},
 			"@container": {
 				type: [
@@ -501,22 +553,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: [
@@ -524,14 +576,14 @@ 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 description$j = "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
+	description: description$j
 };
 
-var type$b = "object";
-var properties$4 = {
+var type$c = "object";
+var properties$5 = {
 	"@graph": {
 		anyOf: [
 			{
@@ -546,73 +598,37 @@ var properties$4 = {
 		]
 	},
 	"@index": {
-		type: "string"
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 	},
 	"@id": {
-		anyOf: [
-			{
-				type: "string"
-			},
-			{
-				type: "array",
-				items: {
-					type: "string"
-				}
-			}
-		]
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 	},
 	"@context": {
-		anyOf: [
-			{
-				type: "null"
-			},
-			{
-				type: "string"
-			},
-			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
-			},
-			{
-				type: "array",
-				items: {
-					anyOf: [
-						{
-							type: "null"
-						},
-						{
-							type: "string"
-						},
-						{
-							$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
-						}
-					]
-				}
-			}
-		]
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 	}
 };
 var required$3 = [
 	"@graph"
 ];
-var additionalProperties$9 = false;
-var description$d = "A graph object represents a named graph, which MAY include an explicit graph name.";
+var additionalProperties$a = false;
+var description$i = "A graph object represents a named graph, which MAY include an explicit graph name.";
 var JsonLdGraphObjectSchema = {
-	type: type$b,
-	properties: properties$4,
+	type: type$c,
+	properties: properties$5,
 	required: required$3,
-	additionalProperties: additionalProperties$9,
-	description: description$d
+	additionalProperties: additionalProperties$a,
+	description: description$i
 };
 
-var type$a = "object";
-var additionalProperties$8 = {
+var type$b = "object";
+var additionalProperties$9 = {
 	$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 description$h = "An id map is used to associate an IRI with a value that allows easy programmatic access.";
 var JsonLdIdMapSchema = {
-	type: type$a,
-	additionalProperties: additionalProperties$8,
-	description: description$c
+	type: type$b,
+	additionalProperties: additionalProperties$9,
+	description: description$h
 };
 
 var anyOf$5 = [
@@ -626,14 +642,14 @@ var anyOf$5 = [
 		}
 	}
 ];
-var description$b = "An included block is used to provide a set of node objects.";
+var description$g = "An included block is used to provide a set of node objects.";
 var JsonLdIncludedBlockSchema = {
 	anyOf: anyOf$5,
-	description: description$b
+	description: description$g
 };
 
-var type$9 = "object";
-var additionalProperties$7 = {
+var type$a = "object";
+var additionalProperties$8 = {
 	anyOf: [
 		{
 			$ref: "https://schema.twindev.org/json-ld/JsonLdIndexMapItem"
@@ -646,11 +662,11 @@ var additionalProperties$7 = {
 		}
 	]
 };
-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 description$f = "An index map allows keys that have no semantic meaning, but should be preserved regardless, to be used in JSON-LD documents.";
 var JsonLdIndexMapSchema = {
-	type: type$9,
-	additionalProperties: additionalProperties$7,
-	description: description$a
+	type: type$a,
+	additionalProperties: additionalProperties$8,
+	description: description$f
 };
 
 var anyOf$4 = [
@@ -679,23 +695,25 @@ 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 description$e = "The items that can be stored in an index map.";
 var JsonLdIndexMapItemSchema = {
 	anyOf: anyOf$4,
-	description: description$9
+	description: description$e
 };
 
-var type$8 = "array";
+var type$9 = "array";
 var items = {
 	$ref: "https://schema.twindev.org/json-ld/JsonLdJsonValue"
 };
+var description$d = "JSON Type for array.";
 var JsonLdJsonArraySchema = {
-	type: type$8,
-	items: items
+	type: type$9,
+	items: items,
+	description: description$d
 };
 
-var type$7 = "object";
-var additionalProperties$6 = {
+var type$8 = "object";
+var additionalProperties$7 = {
 	anyOf: [
 		{
 			$ref: "https://schema.twindev.org/json-ld/JsonLdJsonValue"
@@ -706,19 +724,23 @@ var additionalProperties$6 = {
 		}
 	]
 };
+var description$c = "JSON Type for object.";
 var JsonLdJsonObjectSchema = {
-	type: type$7,
-	additionalProperties: additionalProperties$6
+	type: type$8,
+	additionalProperties: additionalProperties$7,
+	description: description$c
 };
 
-var type$6 = [
+var type$7 = [
 	"string",
 	"number",
 	"boolean",
 	"null"
 ];
+var description$b = "JSON Primitive.";
 var JsonLdJsonPrimitiveSchema = {
-	type: type$6
+	type: type$7,
+	description: description$b
 };
 
 var anyOf$3 = [
@@ -732,12 +754,14 @@ var anyOf$3 = [
 		$ref: "https://schema.twindev.org/json-ld/JsonLdJsonObject"
 	}
 ];
+var description$a = "JSON Value.";
 var JsonLdJsonValueSchema = {
-	anyOf: anyOf$3
+	anyOf: anyOf$3,
+	description: description$a
 };
 
-var type$5 = "object";
-var properties$3 = {
+var type$6 = "object";
+var properties$4 = {
 	"@base": {
 		type: [
 			"string",
@@ -784,33 +808,7 @@ var properties$3 = {
 		]
 	},
 	"@context": {
-		anyOf: [
-			{
-				type: "null"
-			},
-			{
-				type: "string"
-			},
-			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
-			},
-			{
-				type: "array",
-				items: {
-					anyOf: [
-						{
-							type: "null"
-						},
-						{
-							type: "string"
-						},
-						{
-							$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
-						}
-					]
-				}
-			}
-		]
+		$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
 	},
 	"@direction": {
 		type: [
@@ -967,18 +965,18 @@ var required$2 = [
 	"@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 additionalProperties$6 = false;
+var description$9 = "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,
+	type: type$6,
+	properties: properties$4,
 	required: required$2,
-	additionalProperties: additionalProperties$5,
-	description: description$8
+	additionalProperties: additionalProperties$6,
+	description: description$9
 };
 
-var type$4 = "object";
-var additionalProperties$4 = {
+var type$5 = "object";
+var additionalProperties$5 = {
 	anyOf: [
 		{
 			type: "null"
@@ -994,43 +992,33 @@ var additionalProperties$4 = {
 		}
 	]
 };
-var description$7 = "A language map is used to associate a language with a value in a way that allows easy programmatic access.";
+var description$8 = "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
+	type: type$5,
+	additionalProperties: additionalProperties$5,
+	description: description$8
 };
 
-var type$3 = "object";
-var properties$2 = {
+var type$4 = "object";
+var properties$3 = {
 	"@list": {
-		anyOf: [
-			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
-			},
-			{
-				type: "array",
-				items: {
-					$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
-				}
-			}
-		]
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 	},
 	"@index": {
-		type: "string"
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 	}
 };
 var required$1 = [
 	"@list"
 ];
-var additionalProperties$3 = false;
-var description$6 = "A list represents an ordered set of values.";
+var additionalProperties$4 = false;
+var description$7 = "A list represents an ordered set of values.";
 var JsonLdListObjectSchema = {
-	type: type$3,
-	properties: properties$2,
+	type: type$4,
+	properties: properties$3,
 	required: required$1,
-	additionalProperties: additionalProperties$3,
-	description: description$6
+	additionalProperties: additionalProperties$4,
+	description: description$7
 };
 
 var anyOf$2 = [
@@ -1053,58 +1041,47 @@ var anyOf$2 = [
 		$ref: "https://schema.twindev.org/json-ld/JsonLdValueObject"
 	}
 ];
-var description$5 = "A list or set item can be a null, boolean, number, string, node object, or value object.";
+var description$6 = "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
+	description: description$6
 };
 
-var type$2 = "object";
-var properties$1 = {
+var type$3 = "object";
+var additionalProperties$3 = {
+	anyOf: [
+		{
+			$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"
+		},
+		{
+			type: "array"
+		}
+	]
+};
+var properties$2 = {
 	"@context": {
-		anyOf: [
-			{
-				type: "null"
-			},
-			{
-				type: "string"
-			},
-			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
-			},
-			{
-				type: "array",
-				items: {
-					anyOf: [
-						{
-							type: "null"
-						},
-						{
-							type: "string"
-						},
-						{
-							$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
-						}
-					]
-				}
-			}
-		]
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 	},
 	"@id": {
-		anyOf: [
-			{
-				type: "string"
-			},
-			{
-				type: "array",
-				items: {
-					type: "string"
-				}
-			}
-		]
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 	},
 	"@included": {
-		$ref: "https://schema.twindev.org/json-ld/JsonLdIncludedBlock"
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 	},
 	"@graph": {
 		anyOf: [
@@ -1135,12 +1112,12 @@ var properties$1 = {
 	"@type": {
 		anyOf: [
 			{
-				type: "string"
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 			},
 			{
 				type: "array",
 				items: {
-					type: "string"
+					$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 				}
 			}
 		]
@@ -1148,47 +1125,19 @@ var properties$1 = {
 	"@reverse": {
 		type: "object",
 		additionalProperties: {
-			type: "string"
+			$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 		}
 	},
 	"@index": {
-		type: "string"
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 	}
 };
-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 description$5 = "A node object represents zero or more properties of a node in the graph serialized by the JSON-LD document.";
 var JsonLdNodeObjectSchema = {
-	type: type$2,
-	properties: properties$1,
-	additionalProperties: additionalProperties$2,
-	description: description$4
+	type: type$3,
+	additionalProperties: additionalProperties$3,
+	properties: properties$2,
+	description: description$5
 };
 
 var anyOf$1 = [
@@ -1220,29 +1169,88 @@ var anyOf$1 = [
 		$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 description$4 = "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
+	description: description$4
 };
 
-var type$1 = "object";
-var properties = {
-	"@set": {
+var type$2 = "object";
+var properties$1 = {
+	"@context": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	},
+	"@id": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	},
+	"@included": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	},
+	"@graph": {
 		anyOf: [
 			{
-				$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
+				$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
 			},
 			{
 				type: "array",
 				items: {
-					$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
+					$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
 				}
 			}
 		]
 	},
+	"@nest": {
+		anyOf: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdJsonObject"
+			},
+			{
+				type: "array",
+				items: {
+					$ref: "https://schema.twindev.org/json-ld/JsonLdJsonObject"
+				}
+			}
+		]
+	},
+	"@type": {
+		anyOf: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			{
+				type: "array",
+				items: {
+					$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+				}
+			}
+		]
+	},
+	"@reverse": {
+		type: "object",
+		additionalProperties: {
+			$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+		}
+	},
 	"@index": {
-		type: "string"
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	}
+};
+var additionalProperties$2 = false;
+var description$3 = "An object represents the pre-defined properties of the node object in the graph serialized by the JSON-LD document.";
+var JsonLdObjectSchema = {
+	type: type$2,
+	properties: properties$1,
+	additionalProperties: additionalProperties$2,
+	description: description$3
+};
+
+var type$1 = "object";
+var properties = {
+	"@set": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	},
+	"@index": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
 	}
 };
 var required = [
@@ -1373,99 +1381,103 @@ class JsonLdDataTypes {
      * Register all the data types.
      */
     static registerTypes() {
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.Document, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.Document}`, () => ({
             type: JsonLdTypes.Document,
             jsonSchema: async () => JsonLdDocumentSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.NodeObject, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.Object}`, () => ({
+            type: JsonLdTypes.Object,
+            jsonSchema: async () => JsonLdObjectSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.NodeObject}`, () => ({
             type: JsonLdTypes.NodeObject,
             jsonSchema: async () => JsonLdNodeObjectSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.NodePrimitive, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.NodePrimitive}`, () => ({
             type: JsonLdTypes.NodePrimitive,
             jsonSchema: async () => JsonLdNodePrimitiveSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.GraphObject, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.GraphObject}`, () => ({
             type: JsonLdTypes.GraphObject,
             jsonSchema: async () => JsonLdGraphObjectSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ValueObject, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ValueObject}`, () => ({
             type: JsonLdTypes.ValueObject,
             jsonSchema: async () => JsonLdValueObjectSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ListObject, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ListObject}`, () => ({
             type: JsonLdTypes.ListObject,
             jsonSchema: async () => JsonLdListObjectSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ListObject, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ListObject}`, () => ({
             type: JsonLdTypes.ListObject,
             jsonSchema: async () => JsonLdListObjectSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.SetObject, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.SetObject}`, () => ({
             type: JsonLdTypes.SetObject,
             jsonSchema: async () => JsonLdSetObjectSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.LanguageMap, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.LanguageMap}`, () => ({
             type: JsonLdTypes.LanguageMap,
             jsonSchema: async () => JsonLdLanguageMapSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.IndexMap, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.IndexMap}`, () => ({
             type: JsonLdTypes.IndexMap,
             jsonSchema: async () => JsonLdIndexMapSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.IndexMapItem, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.IndexMapItem}`, () => ({
             type: JsonLdTypes.IndexMapItem,
             jsonSchema: async () => JsonLdIndexMapItemSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.IdMap, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.IdMap}`, () => ({
             type: JsonLdTypes.IdMap,
             jsonSchema: async () => JsonLdIdMapSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.TypeMap, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.TypeMap}`, () => ({
             type: JsonLdTypes.TypeMap,
             jsonSchema: async () => JsonLdTypeMapSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.IncludedBlock, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.IncludedBlock}`, () => ({
             type: JsonLdTypes.IncludedBlock,
             jsonSchema: async () => JsonLdIncludedBlockSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ContextDefinition, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ContextDefinition}`, () => ({
             type: JsonLdTypes.ContextDefinition,
             jsonSchema: async () => JsonLdContextDefinitionSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ExpandedTermDefinition, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ExpandedTermDefinition}`, () => ({
             type: JsonLdTypes.ExpandedTermDefinition,
             jsonSchema: async () => JsonLdExpandedTermDefinitionSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.Keyword, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.Keyword}`, () => ({
             type: JsonLdTypes.Keyword,
             jsonSchema: async () => JsonLdKeywordSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ListOrSetItem, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ListOrSetItem}`, () => ({
             type: JsonLdTypes.ListOrSetItem,
             jsonSchema: async () => JsonLdListOrSetItemSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ContainerType, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ContainerType}`, () => ({
             type: JsonLdTypes.ContainerType,
             jsonSchema: async () => JsonLdContainerTypeSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ContainerTypeArray, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.ContainerTypeArray}`, () => ({
             type: JsonLdTypes.ContainerTypeArray,
             jsonSchema: async () => JsonLdContainerTypeArraySchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.JsonPrimitive, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.JsonPrimitive}`, () => ({
             type: JsonLdTypes.JsonPrimitive,
             jsonSchema: async () => JsonLdJsonPrimitiveSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.JsonArray, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.JsonArray}`, () => ({
             type: JsonLdTypes.JsonArray,
             jsonSchema: async () => JsonLdJsonArraySchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.JsonObject, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.JsonObject}`, () => ({
             type: JsonLdTypes.JsonObject,
             jsonSchema: async () => JsonLdJsonObjectSchema
         }));
-        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.JsonValue, () => ({
+        dataCore.DataTypeHandlerFactory.register(`${JsonLdContexts.ContextRoot}${JsonLdTypes.JsonValue}`, () => ({
             type: JsonLdTypes.JsonValue,
             jsonSchema: async () => JsonLdJsonValueSchema
         }));
@@ -1521,26 +1533,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) {
+        core.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 = core.SharedStore.get("jsonLdDocumentLoader");
+        if (core.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 DOCUMENT_LOADER = async (url) => JsonLdProcessor.documentLoader(url);
+    static setCacheLimit(cacheLimitMs) {
+        core.SharedStore.set("jsonLdDocumentCacheLimit", cacheLimitMs);
+    }
+    /**
+     * Get the cache limit for documents.
+     * @returns The document loader.
+     */
+    static getCacheLimit() {
+        let cacheLimitMs = core.SharedStore.get("jsonLdDocumentCacheLimit");
+        if (core.Is.empty(cacheLimitMs)) {
+            cacheLimitMs = 3600000;
+            core.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) {
+        core.SharedStore.set("jsonLdRedirects", redirects);
+    }
+    /**
+     * Get the global redirects for JSON-LD.
+     * @returns The registered redirects.
+     */
+    static getRedirects() {
+        let redirects = core.SharedStore.get("jsonLdRedirects");
+        if (core.Is.empty(redirects)) {
+            redirects = [];
+            core.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.
+     * @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 {
-            return jsonLd.compact(document, context ?? {}, {
-                documentLoader: JsonLdProcessor.DOCUMENT_LOADER
-            });
+            if (core.Is.object(document)) {
+                // If the user didn't provide a context, use the one from the document
+                if (core.Is.empty(context) && !core.Is.empty(document["@context"])) {
+                    context = document["@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 (core.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);
+                    }
+                }
+                const compacted = await jsonLd.compact(core.ObjectHelper.removeEmptyProperties(document), context, {
+                    documentLoader: JsonLdProcessor.getDocumentLoader()
+                });
+                if (!core.Is.empty(overrideContext)) {
+                    // Remove the override context from the compacted document
+                    compacted["@context"] = JsonLdProcessor.removeContexts(compacted["@context"], [overrideContext]);
+                }
+                return compacted;
+            }
+            return document;
         }
         catch (err) {
+            JsonLdProcessor.handleCommonErrors(err);
             throw new core.GeneralError(JsonLdProcessor._CLASS_NAME, "compact", undefined, err);
         }
     }
@@ -1551,24 +1649,189 @@ class JsonLdProcessor {
      */
     static async expand(compacted) {
         try {
-            return jsonLd.expand(compacted, {
-                documentLoader: JsonLdProcessor.DOCUMENT_LOADER
-            });
+            if (core.Is.object(compacted)) {
+                const expanded = await jsonLd.expand(core.ObjectHelper.removeEmptyProperties(compacted), {
+                    documentLoader: JsonLdProcessor.getDocumentLoader()
+                });
+                return expanded;
+            }
+            return [];
         }
         catch (err) {
+            JsonLdProcessor.handleCommonErrors(err);
             throw new core.GeneralError(JsonLdProcessor._CLASS_NAME, "expand", undefined, err);
         }
     }
+    /**
+     * 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 async canonize(document, options) {
+        try {
+            const normalized = await jsonLd.canonize(core.ObjectHelper.removeEmptyProperties(document), {
+                algorithm: options?.algorithm ?? "URDNA2015",
+                format: "application/n-quads",
+                documentLoader: JsonLdProcessor.getDocumentLoader()
+            });
+            return normalized;
+        }
+        catch (err) {
+            JsonLdProcessor.handleCommonErrors(err);
+            throw new core.GeneralError(JsonLdProcessor._CLASS_NAME, "canonize", undefined, err);
+        }
+    }
     /**
      * Add a redirect to use during document resolution.
      * @param from The URL to redirect from.
      * @param to The URL to redirect to.
      */
     static addRedirect(from, to) {
-        if (!this._redirects.some(r => r.from === from)) {
-            this._redirects.push({ from, to });
+        const redirects = JsonLdProcessor.getRedirects();
+        if (!redirects.some(r => r.from === from)) {
+            redirects.push({ from, to });
         }
     }
+    /**
+     * Combine contexts.
+     * @param context1 The first JSON-LD context to combine.
+     * @param context2 The second JSON-LD context to combine.
+     * @returns The combined context.
+     */
+    static combineContexts(context1, context2) {
+        const combinedContext = [];
+        if (core.Is.string(context1)) {
+            if (!combinedContext.includes(context1)) {
+                combinedContext.push(context1);
+            }
+        }
+        else if (core.Is.array(context1)) {
+            for (const context of context1) {
+                const hasMatch = combinedContext.some(c => core.ObjectHelper.equal(c, context));
+                if (!hasMatch) {
+                    combinedContext.push(context);
+                }
+            }
+        }
+        else if (core.Is.object(context1)) {
+            const hasMatch = combinedContext.some(c => core.ObjectHelper.equal(c, context1));
+            if (!hasMatch) {
+                combinedContext.push(context1);
+            }
+        }
+        if (core.Is.string(context2)) {
+            if (!combinedContext.includes(context2)) {
+                combinedContext.push(context2);
+            }
+        }
+        else if (core.Is.array(context2)) {
+            for (const context of context2) {
+                const hasMatch = combinedContext.some(c => core.ObjectHelper.equal(c, context));
+                if (!hasMatch) {
+                    combinedContext.push(context);
+                }
+            }
+        }
+        else if (core.Is.object(context2)) {
+            const hasMatch = combinedContext.some(c => core.ObjectHelper.equal(c, context2));
+            if (!hasMatch) {
+                combinedContext.push(context2);
+            }
+        }
+        if (combinedContext.length === 0) {
+            return null;
+        }
+        if (combinedContext.length === 1) {
+            return combinedContext[0];
+        }
+        return combinedContext;
+    }
+    /**
+     * Gather all the contexts from the element and it's children.
+     * @param element The element to gather the contexts from.
+     * @param initial The initial context.
+     * @returns The combined contexts.
+     */
+    static gatherContexts(element, initial) {
+        let combinedContexts = initial;
+        if (core.Is.object(element)) {
+            if (!core.Is.empty(element["@context"])) {
+                combinedContexts = JsonLdProcessor.combineContexts(initial, element["@context"]);
+            }
+            for (const prop of Object.keys(element)) {
+                const value = element[prop];
+                if (core.Is.object(value)) {
+                    combinedContexts = this.gatherContexts(value, combinedContexts);
+                }
+                else if (core.Is.array(value)) {
+                    for (const item of value) {
+                        if (core.Is.object(item)) {
+                            combinedContexts = this.gatherContexts(item, combinedContexts);
+                        }
+                    }
+                }
+            }
+        }
+        return combinedContexts;
+    }
+    /**
+     * Remove all the contexts that match the pattern.
+     * @param context The context to remove the entries from.
+     * @param match The element to try and match.
+     * @returns The updated contexts.
+     */
+    static removeContexts(context, match) {
+        if (!core.Is.arrayValue(match)) {
+            return context;
+        }
+        let finalContext;
+        if (core.Is.string(context)) {
+            for (const m of match) {
+                if (context === m) {
+                    break;
+                }
+            }
+        }
+        else if (core.Is.array(context)) {
+            for (const item of context) {
+                const hasMatch = match.some(m => core.ObjectHelper.equal(m, item));
+                if (!hasMatch) {
+                    finalContext ??= [];
+                    if (core.Is.array(finalContext)) {
+                        finalContext.push(item);
+                    }
+                }
+            }
+        }
+        else if (core.Is.object(context)) {
+            const hasMatch = match.some(m => core.ObjectHelper.equal(m, context));
+            if (!hasMatch) {
+                finalContext = context;
+            }
+        }
+        return core.Is.arrayValue(finalContext) && finalContext.length === 1
+            ? 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 web.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 web.FetchHelper.removeCacheEntry(url);
+    }
     /**
      * Document loader which uses a caching mechanism.
      * @param url The document url to load.
@@ -1576,7 +1839,8 @@ 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;
@@ -1584,9 +1848,9 @@ class JsonLdProcessor {
         }
         // Cache the results for an hour
         const response = await web.FetchHelper.fetchJson(JsonLdProcessor._CLASS_NAME, url, web.HttpMethod.GET, undefined, {
-            cacheTtlMs: 3600000,
+            cacheTtlMs: JsonLdProcessor.getCacheLimit(),
             headers: {
-                Accept: `${web.MimeTypes.JsonLd},${web.MimeTypes.Json}`
+                [web.HeaderTypes.Accept]: `${web.MimeTypes.JsonLd},${web.MimeTypes.Json}`
             }
         });
         return {
@@ -1594,8 +1858,24 @@ class JsonLdProcessor {
             document: response
         };
     }
+    /**
+     * Handle common errors.
+     * @param err The error to handle.
+     * @internal
+     */
+    static handleCommonErrors(err) {
+        if (core.Is.object(err) &&
+            err.name === "jsonld.InvalidUrl") {
+            throw new core.GeneralError(JsonLdProcessor._CLASS_NAME, "invalidUrl", { url: err.details?.url }, err);
+        }
+        else if (core.Is.object(err) &&
+            err.name.startsWith("jsonld.")) {
+            throw new core.GeneralError(JsonLdProcessor._CLASS_NAME, "jsonLdError", err.details, err);
+        }
+    }
 }
 
+exports.JsonLdContexts = JsonLdContexts;
 exports.JsonLdDataTypes = JsonLdDataTypes;
 exports.JsonLdHelper = JsonLdHelper;
 exports.JsonLdProcessor = JsonLdProcessor;