@twin.org/data-json-ld 0.0.1-next.10

package/dist/cjs/index.cjs

@@ -0,0 +1,1750 @@
+'use strict';
+
+var dataCore = require('@twin.org/data-core');
+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 types of JSON-LD data.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const JsonLdTypes = {
+    /**
+     * Context Root.
+     */
+    ContextRoot: "https://schema.twindev.org/json-ld/",
+    /**
+     * Represents JSON-LD Document.
+     */
+    Document: "https://schema.twindev.org/json-ld/JsonLdDocument",
+    /**
+     * Represents JSON-LD Object.
+     */
+    Object: "https://schema.twindev.org/json-ld/JsonLdObject",
+    /**
+     * Represents JSON-LD Node Object.
+     */
+    NodeObject: "https://schema.twindev.org/json-ld/JsonLdNodeObject",
+    /**
+     * Represents JSON-LD Node Primitive.
+     */
+    NodePrimitive: "https://schema.twindev.org/json-ld/JsonLdNodePrimitive",
+    /**
+     * Represents JSON-LD Graph Object.
+     */
+    GraphObject: "https://schema.twindev.org/json-ld/JsonLdGraphObject",
+    /**
+     * Represents JSON-LD Value Object.
+     */
+    ValueObject: "https://schema.twindev.org/json-ld/JsonLdValueObject",
+    /**
+     * Represents JSON-LD List Object.
+     */
+    ListObject: "https://schema.twindev.org/json-ld/JsonLdListObject",
+    /**
+     * Represents JSON-LD Set Object.
+     */
+    SetObject: "https://schema.twindev.org/json-ld/JsonLdSetObject",
+    /**
+     * Represents JSON-LD Language Map.
+     */
+    LanguageMap: "https://schema.twindev.org/json-ld/JsonLdLanguageMap",
+    /**
+     * Represents JSON-LD Index Map.
+     */
+    IndexMap: "https://schema.twindev.org/json-ld/JsonLdIndexMap",
+    /**
+     * Represents JSON-LD Index Map Item.
+     */
+    IndexMapItem: "https://schema.twindev.org/json-ld/JsonLdIndexMapItem",
+    /**
+     * Represents JSON-LD Id Map.
+     */
+    IdMap: "https://schema.twindev.org/json-ld/JsonLdIdMap",
+    /**
+     * Represents JSON-LD Type Map.
+     */
+    TypeMap: "https://schema.twindev.org/json-ld/JsonLdTypeMap",
+    /**
+     * Represents JSON-LD Included block.
+     */
+    IncludedBlock: "https://schema.twindev.org/json-ld/JsonLdIncludedBlock",
+    /**
+     * Represents JSON-LD Context Definition.
+     */
+    ContextDefinition: "https://schema.twindev.org/json-ld/JsonLdContextDefinition",
+    /**
+     * Represents JSON-LD Expanded Term Definition.
+     */
+    ExpandedTermDefinition: "https://schema.twindev.org/json-ld/JsonLdExpandedTermDefinition",
+    /**
+     * Represents JSON-LD Keyword.
+     */
+    Keyword: "https://schema.twindev.org/json-ld/JsonLdKeyword",
+    /**
+     * Represents JSON-LD List or Set Item.
+     */
+    ListOrSetItem: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem",
+    /**
+     * Represents JSON-LD Container Type.
+     */
+    ContainerType: "https://schema.twindev.org/json-ld/JsonLdContainerType",
+    /**
+     * Represents JSON-LD Container Type Array.
+     */
+    ContainerTypeArray: "https://schema.twindev.org/json-ld/JsonLdContainerTypeArray",
+    /**
+     * Represents JSON-LD JSON Primitive.
+     */
+    JsonPrimitive: "https://schema.twindev.org/json-ld/JsonLdJsonPrimitive",
+    /**
+     * Represents JSON-LD JSON Array.
+     */
+    JsonArray: "https://schema.twindev.org/json-ld/JsonLdJsonArray",
+    /**
+     * Represents JSON-LD JSON Object.
+     */
+    JsonObject: "https://schema.twindev.org/json-ld/JsonLdJsonObject",
+    /**
+     * Represents JSON-LD JSON Value.
+     */
+    JsonValue: "https://schema.twindev.org/json-ld/JsonLdJsonValue"
+};
+
+var type$e = "string";
+var JsonLdContainerTypeSchema = {
+	type: type$e,
+	"enum": [
+	"@language",
+	"@index",
+	"@id",
+	"@graph",
+	"@type"
+]
+};
+
+var anyOf$8 = [
+	{
+		type: "array",
+		minItems: 2,
+		items: [
+			{
+				type: "string",
+				"const": "@graph"
+			},
+			{
+				type: "string",
+				"const": "@id"
+			}
+		],
+		maxItems: 2
+	},
+	{
+		type: "array",
+		minItems: 2,
+		items: [
+			{
+				type: "string",
+				"const": "@id"
+			},
+			{
+				type: "string",
+				"const": "@graph"
+			}
+		],
+		maxItems: 2
+	},
+	{
+		type: "array",
+		minItems: 3,
+		items: [
+			{
+				type: "string",
+				"const": "@set"
+			},
+			{
+				type: "string",
+				"const": "@graph"
+			},
+			{
+				type: "string",
+				"const": "@id"
+			}
+		],
+		maxItems: 3
+	},
+	{
+		type: "array",
+		minItems: 3,
+		items: [
+			{
+				type: "string",
+				"const": "@set"
+			},
+			{
+				type: "string",
+				"const": "@id"
+			},
+			{
+				type: "string",
+				"const": "@graph"
+			}
+		],
+		maxItems: 3
+	},
+	{
+		type: "array",
+		minItems: 3,
+		items: [
+			{
+				type: "string",
+				"const": "@graph"
+			},
+			{
+				type: "string",
+				"const": "@set"
+			},
+			{
+				type: "string",
+				"const": "@id"
+			}
+		],
+		maxItems: 3
+	},
+	{
+		type: "array",
+		minItems: 3,
+		items: [
+			{
+				type: "string",
+				"const": "@id"
+			},
+			{
+				type: "string",
+				"const": "@set"
+			},
+			{
+				type: "string",
+				"const": "@graph"
+			}
+		],
+		maxItems: 3
+	},
+	{
+		type: "array",
+		minItems: 3,
+		items: [
+			{
+				type: "string",
+				"const": "@graph"
+			},
+			{
+				type: "string",
+				"const": "@id"
+			},
+			{
+				type: "string",
+				"const": "@set"
+			}
+		],
+		maxItems: 3
+	},
+	{
+		type: "array",
+		minItems: 3,
+		items: [
+			{
+				type: "string",
+				"const": "@id"
+			},
+			{
+				type: "string",
+				"const": "@graph"
+			},
+			{
+				type: "string",
+				"const": "@set"
+			}
+		],
+		maxItems: 3
+	},
+	{
+		type: "array",
+		minItems: 2,
+		items: [
+			{
+				type: "string",
+				"const": "@set"
+			},
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdContainerType"
+			}
+		],
+		maxItems: 2
+	},
+	{
+		type: "array",
+		minItems: 2,
+		items: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdContainerType"
+			},
+			{
+				type: "string",
+				"const": "@set"
+			}
+		],
+		maxItems: 2
+	}
+];
+var JsonLdContainerTypeArraySchema = {
+	anyOf: anyOf$8
+};
+
+var type$d = "object";
+var properties$6 = {
+	"@base": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	},
+	"@direction": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	},
+	"@import": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	},
+	"@language": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	},
+	"@propagate": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	},
+	"@protected": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	},
+	"@type": {
+		type: "object",
+		properties: {
+			"@container": {
+				type: "string",
+				"const": "@set"
+			},
+			"@protected": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			}
+		},
+		required: [
+			"@container"
+		],
+		additionalProperties: false
+	},
+	"@version": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	},
+	"@vocab": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+	}
+};
+var additionalProperties$b = {
+	anyOf: [
+		{
+			type: "null"
+		},
+		{
+			type: "string"
+		},
+		{
+			$ref: "https://schema.twindev.org/json-ld/JsonLdExpandedTermDefinition"
+		}
+	]
+};
+var description$h = "A context definition defines a local context in a node object.";
+var JsonLdContextDefinitionSchema = {
+	type: type$d,
+	properties: properties$6,
+	additionalProperties: additionalProperties$b,
+	description: description$h
+};
+
+var anyOf$7 = [
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+	},
+	{
+		type: "array",
+		items: {
+			$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+		}
+	},
+	{
+		type: "object",
+		properties: {
+			"@context": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
+			},
+			"@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"
+								}
+							]
+						}
+					}
+				]
+			}
+		},
+		additionalProperties: false
+	}
+];
+var description$g = "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$g
+};
+
+var anyOf$6 = [
+	{
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			"@id": {
+				anyOf: [
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+					},
+					{
+						type: "null"
+					}
+				]
+			},
+			"@nest": {
+				type: "string"
+			},
+			"@container": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@type": {
+				type: "string"
+			},
+			"@language": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@index": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@context": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
+			},
+			"@prefix": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@propagate": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@protected": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			}
+		}
+	},
+	{
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			"@reverse": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@container": {
+				type: [
+					"string",
+					"null"
+				],
+				"enum": [
+					"@set",
+					"@index",
+					null
+				]
+			},
+			"@type": {
+				type: "string"
+			},
+			"@language": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@index": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@context": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinition"
+			},
+			"@prefix": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@propagate": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@protected": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			}
+		},
+		required: [
+			"@reverse"
+		]
+	}
+];
+var description$f = "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$f
+};
+
+var type$c = "object";
+var properties$5 = {
+	"@graph": {
+		anyOf: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+			},
+			{
+				type: "array",
+				items: {
+					$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+				}
+			}
+		]
+	},
+	"@index": {
+		type: "string"
+	},
+	"@id": {
+		anyOf: [
+			{
+				type: "string"
+			},
+			{
+				type: "array",
+				items: {
+					type: "string"
+				}
+			}
+		]
+	},
+	"@context": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
+	}
+};
+var required$3 = [
+	"@graph"
+];
+var additionalProperties$a = false;
+var description$e = "A graph object represents a named graph, which MAY include an explicit graph name.";
+var JsonLdGraphObjectSchema = {
+	type: type$c,
+	properties: properties$5,
+	required: required$3,
+	additionalProperties: additionalProperties$a,
+	description: description$e
+};
+
+var type$b = "object";
+var additionalProperties$9 = {
+	$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+};
+var description$d = "An id map is used to associate an IRI with a value that allows easy programmatic access.";
+var JsonLdIdMapSchema = {
+	type: type$b,
+	additionalProperties: additionalProperties$9,
+	description: description$d
+};
+
+var anyOf$5 = [
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+	},
+	{
+		type: "array",
+		items: {
+			$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+		}
+	}
+];
+var description$c = "An included block is used to provide a set of node objects.";
+var JsonLdIncludedBlockSchema = {
+	anyOf: anyOf$5,
+	description: description$c
+};
+
+var type$a = "object";
+var additionalProperties$8 = {
+	anyOf: [
+		{
+			$ref: "https://schema.twindev.org/json-ld/JsonLdIndexMapItem"
+		},
+		{
+			type: "array",
+			items: {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdIndexMapItem"
+			}
+		}
+	]
+};
+var description$b = "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$a,
+	additionalProperties: additionalProperties$8,
+	description: description$b
+};
+
+var anyOf$4 = [
+	{
+		type: "null"
+	},
+	{
+		type: "boolean"
+	},
+	{
+		type: "number"
+	},
+	{
+		type: "string"
+	},
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+	},
+	{
+		$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$a = "The items that can be stored in an index map.";
+var JsonLdIndexMapItemSchema = {
+	anyOf: anyOf$4,
+	description: description$a
+};
+
+var type$9 = "array";
+var items = {
+	$ref: "https://schema.twindev.org/json-ld/JsonLdJsonValue"
+};
+var JsonLdJsonArraySchema = {
+	type: type$9,
+	items: items
+};
+
+var type$8 = "object";
+var additionalProperties$7 = {
+	anyOf: [
+		{
+			$ref: "https://schema.twindev.org/json-ld/JsonLdJsonValue"
+		},
+		{
+			not: {
+			}
+		}
+	]
+};
+var JsonLdJsonObjectSchema = {
+	type: type$8,
+	additionalProperties: additionalProperties$7
+};
+
+var type$7 = [
+	"string",
+	"number",
+	"boolean",
+	"null"
+];
+var JsonLdJsonPrimitiveSchema = {
+	type: type$7
+};
+
+var anyOf$3 = [
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdJsonPrimitive"
+	},
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdJsonArray"
+	},
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdJsonObject"
+	}
+];
+var JsonLdJsonValueSchema = {
+	anyOf: anyOf$3
+};
+
+var type$6 = "object";
+var properties$4 = {
+	"@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"
+						}
+					]
+				}
+			}
+		]
+	},
+	"@id": {
+		anyOf: [
+			{
+				type: "string"
+			},
+			{
+				type: "array",
+				items: {
+					type: "string"
+				}
+			}
+		]
+	},
+	"@import": {
+		type: "string"
+	},
+	"@included": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdIncludedBlock"
+	},
+	"@index": {
+		type: "string"
+	},
+	"@json": {
+		type: "string",
+		"const": "@json"
+	},
+	"@language": {
+		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"
+	},
+	"@vocab": {
+		type: [
+			"string",
+			"null"
+		]
+	}
+};
+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$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$6,
+	properties: properties$4,
+	required: required$2,
+	additionalProperties: additionalProperties$6,
+	description: description$9
+};
+
+var type$5 = "object";
+var additionalProperties$5 = {
+	anyOf: [
+		{
+			type: "null"
+		},
+		{
+			type: "string"
+		},
+		{
+			type: "array",
+			items: {
+				type: "string"
+			}
+		}
+	]
+};
+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$5,
+	additionalProperties: additionalProperties$5,
+	description: description$8
+};
+
+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"
+				}
+			}
+		]
+	},
+	"@index": {
+		type: "string"
+	}
+};
+var required$1 = [
+	"@list"
+];
+var additionalProperties$4 = false;
+var description$7 = "A list represents an ordered set of values.";
+var JsonLdListObjectSchema = {
+	type: type$4,
+	properties: properties$3,
+	required: required$1,
+	additionalProperties: additionalProperties$4,
+	description: description$7
+};
+
+var anyOf$2 = [
+	{
+		type: "null"
+	},
+	{
+		type: "boolean"
+	},
+	{
+		type: "number"
+	},
+	{
+		type: "string"
+	},
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+	},
+	{
+		$ref: "https://schema.twindev.org/json-ld/JsonLdValueObject"
+	}
+];
+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$6
+};
+
+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": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
+	},
+	"@id": {
+		anyOf: [
+			{
+				type: "string"
+			},
+			{
+				type: "array",
+				items: {
+					type: "string"
+				}
+			}
+		]
+	},
+	"@included": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdIncludedBlock"
+	},
+	"@graph": {
+		anyOf: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+			},
+			{
+				type: "array",
+				items: {
+					$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: [
+			{
+				type: "string"
+			},
+			{
+				type: "array",
+				items: {
+					type: "string"
+				}
+			}
+		]
+	},
+	"@reverse": {
+		type: "object",
+		additionalProperties: {
+			type: "string"
+		}
+	},
+	"@index": {
+		type: "string"
+	}
+};
+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$3,
+	additionalProperties: additionalProperties$3,
+	properties: properties$2,
+	description: description$5
+};
+
+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$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$4
+};
+
+var type$2 = "object";
+var properties$1 = {
+	"@context": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdContextDefinitionRoot"
+	},
+	"@id": {
+		anyOf: [
+			{
+				type: "string"
+			},
+			{
+				type: "array",
+				items: {
+					type: "string"
+				}
+			}
+		]
+	},
+	"@included": {
+		$ref: "https://schema.twindev.org/json-ld/JsonLdIncludedBlock"
+	},
+	"@graph": {
+		anyOf: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+			},
+			{
+				type: "array",
+				items: {
+					$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: [
+			{
+				type: "string"
+			},
+			{
+				type: "array",
+				items: {
+					type: "string"
+				}
+			}
+		]
+	},
+	"@reverse": {
+		type: "object",
+		additionalProperties: {
+			type: "string"
+		}
+	},
+	"@index": {
+		type: "string"
+	}
+};
+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": {
+		anyOf: [
+			{
+				$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
+			},
+			{
+				type: "array",
+				items: {
+					$ref: "https://schema.twindev.org/json-ld/JsonLdListOrSetItem"
+				}
+			}
+		]
+	},
+	"@index": {
+		type: "string"
+	}
+};
+var required = [
+	"@set"
+];
+var additionalProperties$1 = false;
+var description$2 = "A set represents an unordered set of values.";
+var JsonLdSetObjectSchema = {
+	type: type$1,
+	properties: properties,
+	required: required,
+	additionalProperties: additionalProperties$1,
+	description: description$2
+};
+
+var type = "object";
+var additionalProperties = {
+	anyOf: [
+		{
+			type: "string"
+		},
+		{
+			$ref: "https://schema.twindev.org/json-ld/JsonLdNodeObject"
+		}
+	]
+};
+var description$1 = "A type map is used to associate an IRI with a value that allows easy programmatic access.";
+var JsonLdTypeMapSchema = {
+	type: type,
+	additionalProperties: additionalProperties,
+	description: description$1
+};
+
+var anyOf = [
+	{
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			"@value": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@language": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@direction": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@index": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@context": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			}
+		},
+		required: [
+			"@value"
+		]
+	},
+	{
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			"@value": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@type": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@index": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@context": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			}
+		},
+		required: [
+			"@type",
+			"@value"
+		]
+	},
+	{
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			"@value": {
+				anyOf: [
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+					},
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdJsonObject"
+					},
+					{
+						$ref: "https://schema.twindev.org/json-ld/JsonLdJsonArray"
+					}
+				]
+			},
+			"@type": {
+				type: "string",
+				"const": "@json"
+			},
+			"@index": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			},
+			"@context": {
+				$ref: "https://schema.twindev.org/json-ld/JsonLdKeyword"
+			}
+		},
+		required: [
+			"@type",
+			"@value"
+		]
+	}
+];
+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
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Handle all the data types for JSON-LD.
+ */
+class JsonLdDataTypes {
+    /**
+     * Register all the data types.
+     */
+    static registerTypes() {
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.Document, () => ({
+            type: JsonLdTypes.Document,
+            jsonSchema: async () => JsonLdDocumentSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.Object, () => ({
+            type: JsonLdTypes.Object,
+            jsonSchema: async () => JsonLdObjectSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.NodeObject, () => ({
+            type: JsonLdTypes.NodeObject,
+            jsonSchema: async () => JsonLdNodeObjectSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.NodePrimitive, () => ({
+            type: JsonLdTypes.NodePrimitive,
+            jsonSchema: async () => JsonLdNodePrimitiveSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.GraphObject, () => ({
+            type: JsonLdTypes.GraphObject,
+            jsonSchema: async () => JsonLdGraphObjectSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ValueObject, () => ({
+            type: JsonLdTypes.ValueObject,
+            jsonSchema: async () => JsonLdValueObjectSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ListObject, () => ({
+            type: JsonLdTypes.ListObject,
+            jsonSchema: async () => JsonLdListObjectSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ListObject, () => ({
+            type: JsonLdTypes.ListObject,
+            jsonSchema: async () => JsonLdListObjectSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.SetObject, () => ({
+            type: JsonLdTypes.SetObject,
+            jsonSchema: async () => JsonLdSetObjectSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.LanguageMap, () => ({
+            type: JsonLdTypes.LanguageMap,
+            jsonSchema: async () => JsonLdLanguageMapSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.IndexMap, () => ({
+            type: JsonLdTypes.IndexMap,
+            jsonSchema: async () => JsonLdIndexMapSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.IndexMapItem, () => ({
+            type: JsonLdTypes.IndexMapItem,
+            jsonSchema: async () => JsonLdIndexMapItemSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.IdMap, () => ({
+            type: JsonLdTypes.IdMap,
+            jsonSchema: async () => JsonLdIdMapSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.TypeMap, () => ({
+            type: JsonLdTypes.TypeMap,
+            jsonSchema: async () => JsonLdTypeMapSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.IncludedBlock, () => ({
+            type: JsonLdTypes.IncludedBlock,
+            jsonSchema: async () => JsonLdIncludedBlockSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ContextDefinition, () => ({
+            type: JsonLdTypes.ContextDefinition,
+            jsonSchema: async () => JsonLdContextDefinitionSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ExpandedTermDefinition, () => ({
+            type: JsonLdTypes.ExpandedTermDefinition,
+            jsonSchema: async () => JsonLdExpandedTermDefinitionSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.Keyword, () => ({
+            type: JsonLdTypes.Keyword,
+            jsonSchema: async () => JsonLdKeywordSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ListOrSetItem, () => ({
+            type: JsonLdTypes.ListOrSetItem,
+            jsonSchema: async () => JsonLdListOrSetItemSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ContainerType, () => ({
+            type: JsonLdTypes.ContainerType,
+            jsonSchema: async () => JsonLdContainerTypeSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.ContainerTypeArray, () => ({
+            type: JsonLdTypes.ContainerTypeArray,
+            jsonSchema: async () => JsonLdContainerTypeArraySchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.JsonPrimitive, () => ({
+            type: JsonLdTypes.JsonPrimitive,
+            jsonSchema: async () => JsonLdJsonPrimitiveSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.JsonArray, () => ({
+            type: JsonLdTypes.JsonArray,
+            jsonSchema: async () => JsonLdJsonArraySchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.JsonObject, () => ({
+            type: JsonLdTypes.JsonObject,
+            jsonSchema: async () => JsonLdJsonObjectSchema
+        }));
+        dataCore.DataTypeHandlerFactory.register(JsonLdTypes.JsonValue, () => ({
+            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 (core.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 (core.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 (core.Is.object(document)) {
+            // If the graph is a single node, then use the validate the node schema
+            const dataType = document["@type"];
+            if (core.Is.stringValue(dataType)) {
+                await dataCore.DataTypeHelper.validate("document", dataType, document, validationFailures, validationMode);
+            }
+        }
+        return validationFailures.length === 0;
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * JSON-LD Processor.
+ */
+class JsonLdProcessor {
+    /**
+     * The class name.
+     * @internal
+     */
+    static _CLASS_NAME = "JsonLdProcessor";
+    /**
+     * Redirects to use during document resolution.
+     */
+    static _redirects = [];
+    /**
+     * The document loader to use.
+     */
+    static DOCUMENT_LOADER = async (url) => JsonLdProcessor.documentLoader(url);
+    /**
+     * 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.
+     * @returns The compacted JSON-LD document.
+     */
+    static async compact(document, context) {
+        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 (core.Is.empty(context)) {
+                context = {};
+                if (core.Is.array(document)) {
+                    for (const node of document) {
+                        context = JsonLdProcessor.gatherContexts(node, context);
+                    }
+                }
+                else if (core.Is.array(document["@graph"])) {
+                    for (const node of document["@graph"]) {
+                        context = JsonLdProcessor.gatherContexts(node, context);
+                    }
+                }
+                else if (core.Is.object(document)) {
+                    context = JsonLdProcessor.gatherContexts(document, context);
+                }
+            }
+            const compacted = await jsonLd.compact(document, context, {
+                documentLoader: JsonLdProcessor.DOCUMENT_LOADER
+            });
+            return compacted;
+        }
+        catch (err) {
+            if (core.Is.object(err) &&
+                err.name === "jsonld.InvalidUrl") {
+                throw new core.GeneralError(JsonLdProcessor._CLASS_NAME, "invalidUrl", { url: err.details?.url }, err);
+            }
+            throw new core.GeneralError(JsonLdProcessor._CLASS_NAME, "compact", undefined, err);
+        }
+    }
+    /**
+     * Expand a document, removing its context.
+     * @param compacted The compacted JSON-LD document to expand.
+     * @returns The expanded JSON-LD document.
+     */
+    static async expand(compacted) {
+        try {
+            const expanded = await jsonLd.expand(compacted, {
+                documentLoader: JsonLdProcessor.DOCUMENT_LOADER
+            });
+            return expanded;
+        }
+        catch (err) {
+            if (core.Is.object(err) &&
+                err.name === "jsonld.InvalidUrl") {
+                throw new core.GeneralError(JsonLdProcessor._CLASS_NAME, "invalidUrl", { url: err.details?.url }, err);
+            }
+            throw new core.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.
+     */
+    static addRedirect(from, to) {
+        if (!this._redirects.some(r => r.from === from)) {
+            this._redirects.push({ from, to });
+        }
+    }
+    /**
+     * 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.
+     */
+    static extractProperty(nodeObject, propertyNames, deleteProperty = true) {
+        let retVal;
+        for (const prop of propertyNames) {
+            retVal ??= nodeObject[prop];
+            if (deleteProperty) {
+                delete nodeObject[prop];
+            }
+        }
+        return retVal;
+    }
+    /**
+     * 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.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;
+    }
+    /**
+     * Document loader which uses a caching mechanism.
+     * @param url The document url to load.
+     * @returns The document.
+     * @internal
+     */
+    static async documentLoader(url) {
+        for (const redirect of JsonLdProcessor._redirects) {
+            if (redirect.from.test(url)) {
+                url = redirect.to;
+                break;
+            }
+        }
+        // Cache the results for an hour
+        const response = await web.FetchHelper.fetchJson(JsonLdProcessor._CLASS_NAME, url, web.HttpMethod.GET, undefined, {
+            cacheTtlMs: 3600000,
+            headers: {
+                Accept: `${web.MimeTypes.JsonLd},${web.MimeTypes.Json}`
+            }
+        });
+        return {
+            documentUrl: url,
+            document: response
+        };
+    }
+}
+
+exports.JsonLdDataTypes = JsonLdDataTypes;
+exports.JsonLdHelper = JsonLdHelper;
+exports.JsonLdProcessor = JsonLdProcessor;
+exports.JsonLdTypes = JsonLdTypes;